diff --git a/extensions/cornerstone-dicom-seg/src/commandsModule.ts b/extensions/cornerstone-dicom-seg/src/commandsModule.ts
index 1243f6f2457..865edbd5256 100644
--- a/extensions/cornerstone-dicom-seg/src/commandsModule.ts
+++ b/extensions/cornerstone-dicom-seg/src/commandsModule.ts
@@ -6,6 +6,7 @@ import { adaptersRT, adaptersSEG } from '@cornerstonejs/adapters';
 import { createReportDialogPrompt, useUIStateStore } from '@ohif/extension-default';
 
 import PROMPT_RESPONSES from '../../default/src/utils/_shared/PROMPT_RESPONSES';
+import { getSegmentationSaveOptions } from './utils/segmentationConfig';
 
 const getTargetViewport = ({ viewportId, viewportGridService }) => {
   const { viewports, activeViewportId } = viewportGridService.getState();
@@ -34,7 +35,7 @@ const commandsModule = ({
   extensionManager,
   commandsManager,
 }: Types.Extensions.ExtensionParams): Types.Extensions.CommandsModule => {
-  const { segmentationService, displaySetService, viewportGridService } =
+  const { segmentationService, displaySetService, viewportGridService, customizationService } =
     servicesManager.services as AppTypes.Services;
 
   const actions = {
@@ -88,8 +89,21 @@ const commandsModule = ({
      * @returns Returns the generated segmentation data.
      */
     generateSegmentation: ({ segmentationId, options = {} }) => {
+      // `dataSource` (a data source name) is consumed here to resolve the store
+      // overrides; it must not be forwarded to the adapter's generateSegmentation.
+      const { dataSource: dataSourceName, ...generateOptions } = options;
       const segmentation = cornerstoneToolsSegmentation.state.getSegmentation(segmentationId);
-      const predecessorImageId = options.predecessorImageId ?? segmentation.predecessorImageId;
+      const predecessorImageId =
+        generateOptions.predecessorImageId ?? segmentation.predecessorImageId;
+
+      // A data source may override the app-wide `segmentation.store.*` defaults
+      // via `configuration.segmentation.store` (different back ends support
+      // different SEG encodings). Use the named target data source when storing,
+      // otherwise the active one (e.g. download).
+      const dataSourceDefinition = dataSourceName
+        ? extensionManager.getDataSourceDefinition(dataSourceName)
+        : extensionManager.getActiveDataSourceDefinition();
+      const dataSourceStoreOverride = dataSourceDefinition?.configuration?.segmentation?.store;
 
       const { imageIds } = segmentation.representationData.Labelmap;
 
@@ -173,7 +187,8 @@ const commandsModule = ({
 
       const generatedSegmentation = generateSegmentation(referencedImages, labelmap3D, metaData, {
         predecessorImageId,
-        ...options,
+        ...getSegmentationSaveOptions(customizationService, dataSourceStoreOverride),
+        ...generateOptions,
       });
 
       return generatedSegmentation;
@@ -257,6 +272,8 @@ const commandsModule = ({
         const args = {
           segmentationId,
           options: {
+            // Resolve store overrides against the data source we are storing into.
+            dataSource: dataSourceName,
             SeriesDescription: series ? undefined : reportName || label || 'Contour Series',
             SeriesNumber: series ? undefined : 1 + priorSeriesNumber,
             predecessorImageId: series,
@@ -289,6 +306,8 @@ const commandsModule = ({
 
     generateContour: async args => {
       const { segmentationId, options } = args;
+      // `dataSource` is only used by the SEG store path; keep it out of the RTSS options.
+      const { dataSource: _dataSource, ...contourOptions } = options ?? {};
       const segmentations = segmentationService.getSegmentation(segmentationId);
 
       // inject colors to the segmentIndex
@@ -301,10 +320,11 @@ const commandsModule = ({
           Number(segmentIndex)
         );
       });
-      const predecessorImageId = options?.predecessorImageId ?? segmentations.predecessorImageId;
+      const predecessorImageId =
+        contourOptions.predecessorImageId ?? segmentations.predecessorImageId;
       const dataset = await generateRTSSFromRepresentation(segmentations, {
         predecessorImageId,
-        ...options,
+        ...contourOptions,
       });
       return { dataset };
     },
diff --git a/extensions/cornerstone-dicom-seg/src/customizations/segmentationCustomization.ts b/extensions/cornerstone-dicom-seg/src/customizations/segmentationCustomization.ts
new file mode 100644
index 00000000000..b1f03bc91fc
--- /dev/null
+++ b/extensions/cornerstone-dicom-seg/src/customizations/segmentationCustomization.ts
@@ -0,0 +1,24 @@
+import type { SegmentationMode } from '../utils/segmentationConfig';
+
+export type SegmentLabelCustomization = {
+  enabledByDefault?: boolean;
+  labelColor?: number[];
+  hoverTimeout?: number;
+  background?: string;
+};
+
+export type SegmentationStoreCustomization = {
+  defaultMode?: SegmentationMode;
+  transferSyntaxUID?: string;
+};
+
+const segmentationCustomization = {
+  'segmentation.store.defaultMode': 'labelmap' as SegmentationMode,
+  // transferSyntaxUID is configured in app config (customizationService), not here.
+  'segmentation.segmentLabel': {
+    enabledByDefault: false,
+    hoverTimeout: 1,
+  } satisfies SegmentLabelCustomization,
+};
+
+export default segmentationCustomization;
diff --git a/extensions/cornerstone-dicom-seg/src/getCustomizationModule.ts b/extensions/cornerstone-dicom-seg/src/getCustomizationModule.ts
new file mode 100644
index 00000000000..4321fb98ade
--- /dev/null
+++ b/extensions/cornerstone-dicom-seg/src/getCustomizationModule.ts
@@ -0,0 +1,10 @@
+import segmentationCustomization from './customizations/segmentationCustomization';
+
+export default function getCustomizationModule() {
+  return [
+    {
+      name: 'default',
+      value: segmentationCustomization,
+    },
+  ];
+}
diff --git a/extensions/cornerstone-dicom-seg/src/getSopClassHandlerModule.ts b/extensions/cornerstone-dicom-seg/src/getSopClassHandlerModule.ts
index 1bb2b3a8fc4..63286dd51bb 100644
--- a/extensions/cornerstone-dicom-seg/src/getSopClassHandlerModule.ts
+++ b/extensions/cornerstone-dicom-seg/src/getSopClassHandlerModule.ts
@@ -1,16 +1,236 @@
-import { utils, Types as OhifTypes } from '@ohif/core';
+import { utils, Types as OhifTypes, DicomMetadataStore, classes, log } from '@ohif/core';
 import i18n from '@ohif/i18n';
-import { metaData, eventTarget } from '@cornerstonejs/core';
+import { metaData, eventTarget, utilities as csUtils } from '@cornerstonejs/core';
 import { CONSTANTS, segmentation as cstSegmentation } from '@cornerstonejs/tools';
 import { adaptersSEG, Enums } from '@cornerstonejs/adapters';
 
 import { SOPClassHandlerId } from './id';
 import { dicomlabToRGB } from './utils/dicomlabToRGB';
+import { getSegmentationParserType } from './utils/segmentationConfig';
+import {
+  getFrameIndexFromImageId,
+  isLocalSchemeImageId,
+  stripFrameFromImageId,
+} from './utils/segLocalImageIds';
 
 const sopClassUids = ['1.2.840.10008.5.1.4.1.1.66.4', '1.2.840.10008.5.1.4.1.1.66.7'];
+const LABELMAP_SEG_SOP_CLASS_UID = '1.2.840.10008.5.1.4.1.1.66.7';
 
 const loadPromises = {};
 
+const SEG_LOAD_LOG_PREFIX = '[SEG load]';
+
+// Max number of SEG frames fetched/decoded concurrently by the segmentation
+// loader. Hard-coded to 16 for now; intended to become configurable (and to
+// pair with the full-instance prefetch capability) in a follow-up.
+const SEG_FRAME_DECODE_CONCURRENCY = 16;
+
+function _normalizeImageId(imageId: string | string[] | undefined): string | undefined {
+  if (imageId == null) {
+    return undefined;
+  }
+  return Array.isArray(imageId) ? imageId[0] : imageId;
+}
+
+/**
+ * Expands a WADO-RS frame imageId (…/frames/1) into one imageId per frame.
+ * Multiframe SEG is stored as separate /frames/N resources on the server.
+ */
+function getFrameImageIds(segImageId: string, numberOfFrames: number): string[] {
+  const frameMatch = segImageId.match(/(.*\/frames\/)(\d+)(.*)$/);
+  if (!frameMatch || numberOfFrames <= 1) {
+    return [segImageId];
+  }
+
+  const prefix = frameMatch[1];
+  const suffix = frameMatch[3] || '';
+  const frameImageIds: string[] = [];
+
+  for (let frameNumber = 1; frameNumber <= numberOfFrames; frameNumber++) {
+    frameImageIds.push(`${prefix}${frameNumber}${suffix}`);
+  }
+
+  return frameImageIds;
+}
+
+function _getSegNumberOfFrames(instance: Record<string, unknown>): number {
+  const fromTag = Number(instance.NumberOfFrames);
+  if (fromTag > 0) {
+    return fromTag;
+  }
+
+  const perFrame = instance.PerFrameFunctionalGroupsSequence;
+  if (Array.isArray(perFrame) && perFrame.length > 0) {
+    return perFrame.length;
+  }
+
+  return 1;
+}
+
+function _ensureSegImageIdMetadataRegistered(
+  imageId: string | undefined,
+  instance: Record<string, unknown>
+): void {
+  if (!imageId) {
+    return;
+  }
+
+  const metadataProvider = classes.MetadataProvider;
+
+  const StudyInstanceUID = instance.StudyInstanceUID as string | undefined;
+  const SeriesInstanceUID = instance.SeriesInstanceUID as string | undefined;
+  const SOPInstanceUID = (instance.SOPInstanceUID || instance.SopInstanceUID) as
+    | string
+    | undefined;
+
+  if (!StudyInstanceUID || !SeriesInstanceUID || !SOPInstanceUID) {
+    return;
+  }
+
+  metadataProvider.addImageIdToUIDs(imageId, {
+    StudyInstanceUID,
+    SeriesInstanceUID,
+    SOPInstanceUID,
+    frameNumber: getFrameIndexFromImageId(imageId),
+  });
+}
+
+/** Ensures metadataProvider.get('instance', imageId) resolves for frame-qualified local SEG ids. */
+function _ensureSegInstanceMetadataAvailable(
+  imageId: string | undefined,
+  instance: Record<string, unknown>
+): void {
+  if (!imageId) {
+    return;
+  }
+
+  _ensureSegImageIdMetadataRegistered(imageId, instance);
+
+  if (metaData.get('instance', imageId)) {
+    return;
+  }
+
+  const StudyInstanceUID = instance.StudyInstanceUID as string | undefined;
+  const SeriesInstanceUID = instance.SeriesInstanceUID as string | undefined;
+  const SOPInstanceUID = (instance.SOPInstanceUID || instance.SopInstanceUID) as
+    | string
+    | undefined;
+
+  const storedInstance =
+    StudyInstanceUID && SeriesInstanceUID && SOPInstanceUID
+      ? DicomMetadataStore.getInstance(StudyInstanceUID, SeriesInstanceUID, SOPInstanceUID)
+      : undefined;
+
+  classes.MetadataProvider.addCustomMetadata(
+    imageId,
+    'instance',
+    storedInstance || instance
+  );
+}
+
+function _getSegDataSource(extensionManager, instance: Record<string, unknown>) {
+  const StudyInstanceUID = instance.StudyInstanceUID as string | undefined;
+  const SeriesInstanceUID = instance.SeriesInstanceUID as string | undefined;
+  const SOPInstanceUID = (instance.SOPInstanceUID || instance.SopInstanceUID) as
+    | string
+    | undefined;
+
+  let localUrl: string | undefined;
+
+  if (StudyInstanceUID && SeriesInstanceUID && SOPInstanceUID) {
+    const storedInstance = DicomMetadataStore.getInstance(
+      StudyInstanceUID,
+      SeriesInstanceUID,
+      SOPInstanceUID
+    );
+    localUrl = storedInstance?.url as string | undefined;
+  }
+
+  localUrl = localUrl || (instance.url as string | undefined);
+
+  if (localUrl && isLocalSchemeImageId(localUrl)) {
+    const dicomLocal = extensionManager.getDataSources('dicomlocal');
+
+    if (dicomLocal?.[0]) {
+      return dicomLocal[0];
+    }
+  }
+
+  return extensionManager.getActiveDataSource()[0];
+}
+
+function _getSegImageIdFromInstance(
+  instance: Record<string, unknown>,
+  dataSource: { getImageIdsForInstance?: (args: { instance: unknown; frame?: number }) => unknown }
+): string | undefined {
+  const numberOfFrames = _getSegNumberOfFrames(instance);
+  const frame = numberOfFrames > 1 ? 1 : undefined;
+
+  return _normalizeImageId(
+    dataSource.getImageIdsForInstance?.({ instance, frame }) as string | string[] | undefined
+  );
+}
+
+function _resolveFrameImageIds(
+  segImageIdStr: string,
+  instance: Record<string, unknown>,
+  dataSource: { getImageIdsForInstance?: (args: { instance: unknown; frame?: number }) => unknown }
+): string[] {
+  const numberOfFrames = _getSegNumberOfFrames(instance);
+  const fromFrameUrl = getFrameImageIds(segImageIdStr, numberOfFrames);
+
+  if (fromFrameUrl.length > 1) {
+    return fromFrameUrl;
+  }
+
+  if (numberOfFrames <= 1) {
+    return [segImageIdStr];
+  }
+
+  const frameImageIds: string[] = [];
+
+  for (let frame = 1; frame <= numberOfFrames; frame++) {
+    const frameImageId = _normalizeImageId(
+      dataSource.getImageIdsForInstance?.({ instance, frame }) as string | string[] | undefined
+    );
+
+    if (frameImageId) {
+      frameImageIds.push(frameImageId);
+    }
+  }
+
+  return frameImageIds.length ? frameImageIds : [segImageIdStr];
+}
+
+function _logSegImageIds({
+  segDisplaySet,
+  segImageIdStr,
+  frameImageIds,
+  referencedImageIds,
+}: {
+  segDisplaySet: AppTypes.DisplaySet;
+  segImageIdStr: string;
+  frameImageIds: string[];
+  referencedImageIds: string[];
+}) {
+  const instance = segDisplaySet.instance as Record<string, unknown>;
+  const numberOfFrames = Number(instance?.NumberOfFrames) || 1;
+
+  log.debug(SEG_LOAD_LOG_PREFIX, 'Loading SEG pixel data', {
+    SOPInstanceUID: segDisplaySet.SOPInstanceUID,
+    SeriesInstanceUID: segDisplaySet.SeriesInstanceUID,
+    SOPClassUID: segDisplaySet.SOPClassUID,
+    NumberOfFrames: numberOfFrames,
+    segmentCount: Object.keys(segDisplaySet.segments || {}).length,
+    referencedDisplaySetInstanceUID: segDisplaySet.referencedDisplaySetInstanceUID,
+    referencedImageIdCount: referencedImageIds.length,
+    referencedImageIds,
+    segImageIdForMetadata: segImageIdStr,
+    frameImageIds,
+    loadSegFramesIndividually: frameImageIds.length > 1,
+  });
+}
+
 function _getDisplaySetsFromSeries(
   instances,
   servicesManager: AppTypes.ServicesManager,
@@ -171,6 +391,11 @@ function _load(
       });
   });
 
+  // Expose the in-flight load promise so observers (e.g. the viewport service
+  // waiting to attach the representation) can react to a load failure without
+  // re-invoking load().
+  segDisplaySet.loadingPromise = loadPromises[SOPInstanceUID];
+
   return loadPromises[SOPInstanceUID];
 }
 
@@ -178,16 +403,18 @@ async function _loadSegments({
   extensionManager,
   servicesManager,
   segDisplaySet,
-  headers,
-}: withAppTypes) {
-  const utilityModule = extensionManager.getModuleEntry(
-    '@ohif/extension-cornerstone.utilityModule.common'
-  );
-
-  const { segmentationService, uiNotificationService } = servicesManager.services;
-
-  const { dicomLoaderService } = utilityModule.exports;
-  const arrayBuffer = await dicomLoaderService.findDicomDataPromise(segDisplaySet, null, headers);
+}: withAppTypes<{ segDisplaySet: AppTypes.DisplaySet }>) {
+  const { segmentationService, uiNotificationService, customizationService } =
+    servicesManager.services;
+  const instance = segDisplaySet.instance as Record<string, unknown>;
+  const dataSource = _getSegDataSource(extensionManager, instance);
+  const segImageIdStr = _getSegImageIdFromInstance(instance, dataSource);
+
+  if (!segImageIdStr) {
+    throw new Error(
+      'Could not get imageId for SEG instance (no local wadouri url and getImageIdsForInstance returned nothing).'
+    );
+  }
 
   const referencedDisplaySet = servicesManager.services.displaySetService.getDisplaySetByUID(
     segDisplaySet.referencedDisplaySetInstanceUID
@@ -197,31 +424,118 @@ async function _loadSegments({
     throw new Error('referencedDisplaySet is missing for SEG');
   }
 
+  // Prefer cached stack imageIds (multiframe SEG fix #4890), then data source expansion.
   let { imageIds } = referencedDisplaySet;
 
-  if (!imageIds) {
-    // try images
-    const { images } = referencedDisplaySet;
-    imageIds = images.map(image => image.imageId);
+  if (!imageIds?.length) {
+    imageIds = dataSource.getImageIdsForDisplaySet?.(referencedDisplaySet);
+  }
+
+  if (!imageIds?.length) {
+    imageIds = (referencedDisplaySet as { images?: { imageId: string }[] }).images?.map(
+      (img: { imageId: string }) => img.imageId
+    );
+  }
+
+  if (!imageIds?.length) {
+    throw new Error('referencedDisplaySet has no imageIds');
+  }
+
+  (segDisplaySet as AppTypes.DisplaySet & { referencedImageIds?: string[] }).referencedImageIds =
+    imageIds;
+
+  if (!referencedDisplaySet.imageIds?.length) {
+    referencedDisplaySet.imageIds = imageIds;
   }
 
-  // Todo: what should be defaults here
+  const frameImageIds = _resolveFrameImageIds(
+    segImageIdStr,
+    segDisplaySet.instance as Record<string, unknown>,
+    dataSource
+  );
+
+  const segImageIdForMetadata = isLocalSchemeImageId(segImageIdStr)
+    ? stripFrameFromImageId(segImageIdStr)
+    : segImageIdStr;
+
+  _logSegImageIds({
+    segDisplaySet,
+    segImageIdStr: segImageIdForMetadata,
+    frameImageIds,
+    referencedImageIds: imageIds,
+  });
+
+  _ensureSegInstanceMetadataAvailable(segImageIdForMetadata, instance);
+  frameImageIds.forEach(id => _ensureSegInstanceMetadataAvailable(id, instance));
+
   const tolerance = 0.001;
-  eventTarget.addEventListener(Enums.Events.SEGMENTATION_LOAD_PROGRESS, evt => {
+  const onProgress = evt => {
     const { percentComplete } = evt.detail;
     segmentationService._broadcastEvent(segmentationService.EVENTS.SEGMENT_LOADING_COMPLETE, {
       percentComplete,
     });
-  });
+  };
+  eventTarget.addEventListener(Enums.Events.SEGMENTATION_LOAD_PROGRESS, onProgress);
+
+  // Optional: fetch the whole SEG instance as a single Part 10 object and
+  // register its per-frame compressed pixels into the Cornerstone3D frame
+  // registry, so the per-frame loads below are served locally instead of one
+  // network request per frame. Disabled (0) by default; opt-in via
+  // customization. Best-effort: any failure falls back to per-frame fetches.
+  const loadMultiframeAsPart10RaceTimeMs =
+    (dataSource?.getConfig?.()?.loadMultiframeAsPart10RaceTimeMs as
+      | number
+      | undefined) ??
+    (customizationService?.getCustomization?.(
+      'cornerstone.segmentation.loadMultiframeAsPart10RaceTimeMs'
+    ) as number | undefined) ??
+    0;
+
+  let prefetch;
+  if (loadMultiframeAsPart10RaceTimeMs > 0) {
+    prefetch = dataSource.retrieve?.prefetchInstanceFrames?.({
+      instance,
+      imageId: segImageIdForMetadata,
+      loadMultiframeAsPart10RaceTimeMs,
+    });
 
-  const results = await adaptersSEG.Cornerstone3D.Segmentation.createFromDICOMSegBuffer(
-    imageIds,
-    arrayBuffer,
-    { metadataProvider: metaData, tolerance }
-  );
+    if (prefetch?.done) {
+      // Give the bulk fetch a head start, then proceed regardless: frames
+      // already registered are served locally; the rest fetch normally while
+      // registration continues in the background.
+      const raceTimer = new Promise(resolve =>
+        setTimeout(resolve, loadMultiframeAsPart10RaceTimeMs)
+      );
+      await Promise.race([prefetch.done, raceTimer]);
+    }
+  }
+
+  let results;
+  try {
+    results = await adaptersSEG.Cornerstone3D.Segmentation.createFromDicomSegImageId(
+      imageIds,
+      segImageIdForMetadata,
+      {
+        metadataProvider: metaData,
+        tolerance,
+        parserType: getSegmentationParserType(
+          segDisplaySet.SOPClassUID,
+          customizationService
+        ),
+        frameImageIds,
+        concurrency: SEG_FRAME_DECODE_CONCURRENCY,
+      }
+    );
+  } finally {
+    eventTarget.removeEventListener(Enums.Events.SEGMENTATION_LOAD_PROGRESS, onProgress);
+    prefetch?.cancel?.();
+  }
 
   let usedRecommendedDisplayCIELabValue = true;
-  results.segMetadata.data.forEach((data, i) => {
+  const resultsTyped = results as {
+    segMetadata: { data: { rgba?: number[]; RecommendedDisplayCIELabValue?: number[] }[] };
+  };
+  resultsTyped.segMetadata.data.forEach((data, i) => {
     if (i > 0) {
       data.rgba = data.RecommendedDisplayCIELabValue;
 
@@ -246,6 +560,17 @@ async function _loadSegments({
   }
 
   Object.assign(segDisplaySet, results);
+
+  const labelMapImageIds = (results as { labelMapImages?: { imageId: string }[][] })
+    .labelMapImages?.flat()
+    .map(image => image.imageId);
+
+  log.debug(SEG_LOAD_LOG_PREFIX, 'SEG parse complete', {
+    SOPInstanceUID: segDisplaySet.SOPInstanceUID,
+    labelMapImageCount: labelMapImageIds?.length ?? 0,
+    labelMapImageIds,
+    segmentIndices: Object.keys(segDisplaySet.segments || {}),
+  });
 }
 
 function _segmentationExists(segDisplaySet) {
diff --git a/extensions/cornerstone-dicom-seg/src/index.tsx b/extensions/cornerstone-dicom-seg/src/index.tsx
index e1315b63120..b9fb15a7053 100644
--- a/extensions/cornerstone-dicom-seg/src/index.tsx
+++ b/extensions/cornerstone-dicom-seg/src/index.tsx
@@ -4,6 +4,7 @@ import React from 'react';
 import getSopClassHandlerModule from './getSopClassHandlerModule';
 import getHangingProtocolModule from './getHangingProtocolModule';
 import getCommandsModule from './commandsModule';
+import getCustomizationModule from './getCustomizationModule';
 import { getToolbarModule } from './getToolbarModule';
 
 const Component = React.lazy(() => {
@@ -28,6 +29,7 @@ const extension = {
    */
   id,
   getCommandsModule,
+  getCustomizationModule,
   getToolbarModule,
   getViewportModule({ servicesManager, extensionManager, commandsManager }) {
     const ExtendedOHIFCornerstoneSEGViewport = props => {
diff --git a/extensions/cornerstone-dicom-seg/src/utils/segLocalImageIds.ts b/extensions/cornerstone-dicom-seg/src/utils/segLocalImageIds.ts
new file mode 100644
index 00000000000..6a4b6388328
--- /dev/null
+++ b/extensions/cornerstone-dicom-seg/src/utils/segLocalImageIds.ts
@@ -0,0 +1,32 @@
+export function isLocalSchemeImageId(imageId: string): boolean {
+  return /^(wadouri:|dicomfile:|dicomweb:)/.test(imageId);
+}
+
+export function stripFrameFromImageId(imageId: string): string {
+  const queryIndex = imageId.indexOf('?');
+  if (queryIndex === -1) {
+    return imageId;
+  }
+
+  const basePath = imageId.slice(0, queryIndex);
+  const rebuiltQuery = imageId
+    .slice(queryIndex + 1)
+    .split('&')
+    .filter(param => param.split('=')[0] !== 'frame')
+    .join('&');
+
+  return rebuiltQuery ? `${basePath}?${rebuiltQuery}` : basePath;
+}
+
+export function appendFrameToImageId(baseImageId: string, frame: number): string {
+  const withoutFrame = stripFrameFromImageId(baseImageId);
+  const separator = withoutFrame.includes('?') ? '&' : '?';
+
+  return `${withoutFrame}${separator}frame=${frame}`;
+}
+
+export function getFrameIndexFromImageId(imageId: string): number {
+  const frameMatch = imageId.match(/(?:&|\?)frame=(\d+)/);
+
+  return frameMatch ? Number(frameMatch[1]) : 1;
+}
diff --git a/extensions/cornerstone-dicom-seg/src/utils/segmentationConfig.ts b/extensions/cornerstone-dicom-seg/src/utils/segmentationConfig.ts
new file mode 100644
index 00000000000..54c74d7e5bc
--- /dev/null
+++ b/extensions/cornerstone-dicom-seg/src/utils/segmentationConfig.ts
@@ -0,0 +1,100 @@
+export const LABELMAP_SEG_SOP_CLASS_UID = '1.2.840.10008.5.1.4.1.1.66.7';
+export const BITMAP_SEG_SOP_CLASS_UID = '1.2.840.10008.5.1.4.1.1.66.4';
+
+export type SegmentationMode = 'labelmap' | 'bitmap';
+
+/**
+ * Per-data-source overrides for the SEG store defaults. A data source may set
+ * these under `configuration.segmentation.store` to override the values coming
+ * from the `segmentation.store.*` customizations. Different back ends support
+ * different SEG encodings, so the data source is allowed to win over the
+ * app-wide customization default.
+ */
+export type SegmentationStoreOverride = {
+  defaultMode?: SegmentationMode;
+  transferSyntaxUID?: string;
+};
+
+type SegmentationCustomizationReader = {
+  getCustomization: (customizationId: string) => unknown;
+};
+
+function getStoreDefaultMode(
+  customizationService?: SegmentationCustomizationReader,
+  override?: SegmentationStoreOverride
+): SegmentationMode {
+  // Data-source override wins over the customization default.
+  const mode =
+    override?.defaultMode ??
+    (customizationService?.getCustomization('segmentation.store.defaultMode') as
+      | SegmentationMode
+      | undefined);
+
+  return mode === 'bitmap' ? 'bitmap' : 'labelmap';
+}
+
+function getStoreTransferSyntaxUID(
+  customizationService?: SegmentationCustomizationReader,
+  override?: SegmentationStoreOverride
+): string | undefined {
+  // Data-source override wins over the customization default.
+  const transferSyntaxUID =
+    override?.transferSyntaxUID ??
+    (customizationService?.getCustomization('segmentation.store.transferSyntaxUID') as
+      | string
+      | undefined);
+
+  return transferSyntaxUID || undefined;
+}
+
+/**
+ * Resolves the parser type for loading a DICOM SEG instance.
+ * Uses the instance SOP Class UID when it is a known SEG class; otherwise falls back to store defaultMode.
+ */
+export function getSegmentationParserType(
+  sopClassUID: string | undefined,
+  customizationService?: SegmentationCustomizationReader
+): SegmentationMode {
+  if (sopClassUID === LABELMAP_SEG_SOP_CLASS_UID) {
+    return 'labelmap';
+  }
+
+  if (sopClassUID === BITMAP_SEG_SOP_CLASS_UID) {
+    return 'bitmap';
+  }
+
+  return getStoreDefaultMode(customizationService) === 'labelmap' ? 'labelmap' : 'bitmap';
+}
+
+/**
+ * Options passed to @cornerstonejs/adapters generateSegmentation when exporting or storing SEG.
+ *
+ * @param customizationService - reads the app-wide `segmentation.store.*` defaults.
+ * @param override - optional per-data-source override (e.g.
+ *   `configuration.segmentation.store`) that takes precedence over the customization.
+ */
+export function getSegmentationSaveOptions(
+  customizationService?: SegmentationCustomizationReader,
+  override?: SegmentationStoreOverride
+): {
+  sopClassUID: string;
+  transferSyntaxUID?: string;
+} {
+  const defaultMode = getStoreDefaultMode(customizationService, override);
+  const sopClassUID =
+    defaultMode === 'bitmap' ? BITMAP_SEG_SOP_CLASS_UID : LABELMAP_SEG_SOP_CLASS_UID;
+  const transferSyntaxUID = getStoreTransferSyntaxUID(customizationService, override);
+
+  const options: {
+    sopClassUID: string;
+    transferSyntaxUID?: string;
+    transferSyntaxUid?: string;
+  } = { sopClassUID };
+
+  if (transferSyntaxUID) {
+    options.transferSyntaxUID = transferSyntaxUID;
+    options.transferSyntaxUid = transferSyntaxUID;
+  }
+
+  return options;
+}
diff --git a/extensions/cornerstone-dicom-seg/src/viewports/OHIFCornerstoneSEGViewport.tsx b/extensions/cornerstone-dicom-seg/src/viewports/OHIFCornerstoneSEGViewport.tsx
index 4cc6edcc38c..c565d5292c3 100644
--- a/extensions/cornerstone-dicom-seg/src/viewports/OHIFCornerstoneSEGViewport.tsx
+++ b/extensions/cornerstone-dicom-seg/src/viewports/OHIFCornerstoneSEGViewport.tsx
@@ -95,10 +95,13 @@ function OHIFCornerstoneSEGViewport(props: withAppTypes) {
   };
 
   const getCornerstoneViewport = useCallback(() => {
+    // Stack uses the referenced series (data[0]); SEG is applied as an overlay (data[1]).
+    // Passing only the SEG display set leaves the stack with derived labelmap imageIds,
+    // which are not displayable without the underlying grayscale series.
     return (
       <OHIFCornerstoneViewport
         {...props}
-        displaySets={[segDisplaySet]}
+        displaySets={[referencedDisplaySet, segDisplaySet]}
         viewportOptions={{
           viewportType: viewportOptions.viewportType,
           toolGroupId: toolGroupId,
@@ -111,7 +114,14 @@ function OHIFCornerstoneSEGViewport(props: withAppTypes) {
         }}
       />
     );
-  }, [viewportId, segDisplaySet, toolGroupId, props, viewportOptions]);
+  }, [
+    viewportId,
+    segDisplaySet,
+    referencedDisplaySet,
+    toolGroupId,
+    props,
+    viewportOptions,
+  ]);
 
   useEffect(() => {
     if (segIsLoading) {
diff --git a/extensions/cornerstone-dicom-sr/package.json b/extensions/cornerstone-dicom-sr/package.json
index e75357cb387..c6fbd6d0bdb 100644
--- a/extensions/cornerstone-dicom-sr/package.json
+++ b/extensions/cornerstone-dicom-sr/package.json
@@ -32,7 +32,7 @@
     "@ohif/core": "workspace:*",
     "@ohif/extension-cornerstone": "workspace:*",
     "@ohif/ui": "workspace:*",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "dicom-parser": "1.8.21",
     "hammerjs": "2.0.8",
     "prop-types": "15.8.1",
diff --git a/extensions/cornerstone-dynamic-volume/package.json b/extensions/cornerstone-dynamic-volume/package.json
index 4463881e75f..11605273f01 100644
--- a/extensions/cornerstone-dynamic-volume/package.json
+++ b/extensions/cornerstone-dynamic-volume/package.json
@@ -37,7 +37,7 @@
     "@ohif/extension-default": "workspace:*",
     "@ohif/i18n": "workspace:*",
     "@ohif/ui": "workspace:*",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "dicom-parser": "1.8.21",
     "hammerjs": "2.0.8",
     "prop-types": "15.8.1",
diff --git a/extensions/cornerstone/package.json b/extensions/cornerstone/package.json
index 6d41eb7692b..3871a098ece 100644
--- a/extensions/cornerstone/package.json
+++ b/extensions/cornerstone/package.json
@@ -42,7 +42,7 @@
     "@ohif/core": "workspace:*",
     "@ohif/extension-default": "workspace:*",
     "@ohif/ui": "workspace:*",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "dicom-parser": "1.8.21",
     "hammerjs": "2.0.8",
     "prop-types": "15.8.1",
diff --git a/extensions/cornerstone/src/Viewport/Overlays/CustomizableViewportOverlay.tsx b/extensions/cornerstone/src/Viewport/Overlays/CustomizableViewportOverlay.tsx
index f2f0ee1ffa3..e9a91a92091 100644
--- a/extensions/cornerstone/src/Viewport/Overlays/CustomizableViewportOverlay.tsx
+++ b/extensions/cornerstone/src/Viewport/Overlays/CustomizableViewportOverlay.tsx
@@ -350,7 +350,10 @@ function _getInstanceNumberFromVolume(
     const imageId = imageIds[imageIndex];
 
     if (!imageId) {
-      return {};
+      // No image at this index (e.g. a single-image volume scrolled out of
+      // range). Return undefined so the overlay falls back to the slice count
+      // instead of rendering an empty object as "[object Object]".
+      return;
     }
 
     const { instanceNumber } = metaData.get('generalImageModule', imageId) || {};
diff --git a/extensions/cornerstone/src/commandsModule.ts b/extensions/cornerstone/src/commandsModule.ts
index a2e059d5782..ad77a0aba5f 100644
--- a/extensions/cornerstone/src/commandsModule.ts
+++ b/extensions/cornerstone/src/commandsModule.ts
@@ -1982,8 +1982,15 @@ function commandsModule({
      * Use it before initializing the toolGroup with the tools.
      */
     initializeSegmentLabelTool: ({ tools }) => {
-      const appConfig = extensionManager.appConfig;
-      const segmentLabelConfig = appConfig.segmentation?.segmentLabel;
+      const { customizationService } = servicesManager.services;
+      const segmentLabelConfig = customizationService.getCustomization(
+        'segmentation.segmentLabel'
+      ) as {
+        enabledByDefault?: boolean;
+        labelColor?: number[];
+        hoverTimeout?: number;
+        background?: string;
+      };
 
       if (segmentLabelConfig?.enabledByDefault) {
         const activeTools = tools?.active ?? [];
diff --git a/extensions/cornerstone/src/services/SegmentationService/SegmentationService.test.ts b/extensions/cornerstone/src/services/SegmentationService/SegmentationService.test.ts
index 95581eaad59..8ad9bd959be 100644
--- a/extensions/cornerstone/src/services/SegmentationService/SegmentationService.test.ts
+++ b/extensions/cornerstone/src/services/SegmentationService/SegmentationService.test.ts
@@ -1799,6 +1799,10 @@ describe('SegmentationService', () => {
       const segmentationId = 'segmentationId';
       const segmentationData = {
         segmentationId,
+        representation: {
+          type: csToolsEnums.SegmentationRepresentations.Labelmap,
+          data: {},
+        },
         config: {
           label: 'Segmentation 1',
         },
diff --git a/extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts b/extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts
index a5cc6b8617c..e27569bf331 100644
--- a/extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts
+++ b/extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts
@@ -302,7 +302,15 @@ class SegmentationService extends PubSubService {
     }
   ): Promise<void> {
     const segmentation = this.getSegmentation(segmentationId);
-    if (segmentation && !segmentation.predecessorImageId && predecessorImageId) {
+
+    if (!segmentation) {
+      console.warn(
+        `addSegmentationRepresentation: segmentation "${segmentationId}" is not in state yet`
+      );
+      return;
+    }
+
+    if (!segmentation.predecessorImageId && predecessorImageId) {
       segmentation.predecessorImageId = predecessorImageId;
     }
     const csViewport = this.getAndValidateViewport(viewportId);
@@ -488,7 +496,15 @@ class SegmentationService extends PubSubService {
       throw new Error('No instances were provided for the referenced display set of the SEG');
     }
 
-    const imageIds = images.map(image => image.imageId);
+    // Use the same imageIds as SEG parse (_loadSegments stores these on segDisplaySet).
+    const imageIds =
+      segDisplaySet.referencedImageIds ||
+      (referencedDisplaySet.imageIds as string[] | undefined) ||
+      images.map(image => image.imageId);
+
+    if (!imageIds?.length) {
+      throw new Error('referencedDisplaySet has no imageIds for SEG');
+    }
     const derivedImages = labelMapImages?.flat();
     const derivedImageIds = derivedImages.map(image => image.imageId);
 
@@ -572,11 +588,6 @@ class SegmentationService extends PubSubService {
     const colorLUTIndex = addColorLUT(colorLUT);
     this._segmentationIdToColorLUTIndexMap.set(segmentationId, colorLUTIndex);
 
-    this._broadcastEvent(EVENTS.SEGMENTATION_LOADING_COMPLETE, {
-      segmentationId,
-      segDisplaySet,
-    });
-
     const seg: cstTypes.SegmentationPublicInput = {
       segmentationId,
       representation: {
@@ -596,8 +607,18 @@ class SegmentationService extends PubSubService {
 
     segDisplaySet.isLoaded = true;
 
+    // Add the segmentation to cornerstone state BEFORE broadcasting that loading is
+    // complete. Subscribers (e.g. CornerstoneViewportService) react synchronously and
+    // call addSegmentationRepresentation, which now early-returns when the segmentation
+    // is not yet in cornerstone state. Broadcasting first would make that guard always
+    // fire on initial load, silently preventing the representation from being attached.
     this.addOrUpdateSegmentation(seg);
 
+    this._broadcastEvent(EVENTS.SEGMENTATION_LOADING_COMPLETE, {
+      segmentationId,
+      segDisplaySet,
+    });
+
     return segmentationId;
   }
 
@@ -772,9 +793,16 @@ class SegmentationService extends PubSubService {
     if (existingSegmentation) {
       // Update the existing segmentation
       this.updateSegmentationInSource(segmentationId, data as Partial<cstTypes.Segmentation>);
-    } else {
+    } else if (
+      'representation' in data &&
+      (data as cstTypes.SegmentationPublicInput).representation
+    ) {
       // Add a new segmentation
       this.addSegmentationToSource(data as cstTypes.SegmentationPublicInput);
+    } else {
+      console.warn(
+        `addOrUpdateSegmentation: skipping add for ${segmentationId} — missing representation`
+      );
     }
   }
 
@@ -1596,7 +1624,13 @@ class SegmentationService extends PubSubService {
 
   private determineViewportAndSegmentationType(csViewport, segmentation) {
     const isVolumeViewport = isVolumeViewportType(csViewport);
-    const isVolumeSegmentation = 'volumeId' in segmentation.representationData[LABELMAP];
+    const labelmapData = segmentation?.representationData?.[LABELMAP];
+
+    if (!labelmapData) {
+      return { isVolumeViewport, isVolumeSegmentation: false };
+    }
+
+    const isVolumeSegmentation = 'volumeId' in labelmapData;
     return { isVolumeViewport, isVolumeSegmentation };
   }
 
diff --git a/extensions/cornerstone/src/services/ViewportService/CornerstoneViewportService.ts b/extensions/cornerstone/src/services/ViewportService/CornerstoneViewportService.ts
index 79b9820877a..0cda148fe31 100644
--- a/extensions/cornerstone/src/services/ViewportService/CornerstoneViewportService.ts
+++ b/extensions/cornerstone/src/services/ViewportService/CornerstoneViewportService.ts
@@ -1294,24 +1294,97 @@ class CornerstoneViewportService extends PubSubService implements IViewportServi
         ? csToolsEnums.SegmentationRepresentations.Labelmap
         : csToolsEnums.SegmentationRepresentations.Contour;
 
-    const { predecessorImageId } = displaySet;
-    const segmentationRepresentationPromise = segmentationService.addSegmentationRepresentation(
-      viewport.id,
-      {
-        segmentationId,
-        predecessorImageId,
-        type: representationType,
-        config: {
-          blendMode:
-            viewport?.getBlendMode?.() === 1
-              ? BlendModes.LABELMAP_EDGE_PROJECTION_BLEND
-              : undefined,
-        },
+    const applyRepresentation = () => {
+      const { predecessorImageId } = displaySet;
+      const segmentationRepresentationPromise =
+        segmentationService.addSegmentationRepresentation(viewport.id, {
+          segmentationId,
+          predecessorImageId,
+          type: representationType,
+          config: {
+            blendMode:
+              viewport?.getBlendMode?.() === 1
+                ? BlendModes.LABELMAP_EDGE_PROJECTION_BLEND
+                : undefined,
+          },
+        });
+      this.storePresentation({ viewportId: viewport.id });
+      return segmentationRepresentationPromise;
+    };
+
+    // SEG overlay is registered during stack setup, but cornerstone segmentation state
+    // is created in displaySet.load() (async). Wait until it exists before adding representation.
+    if (displaySet.Modality === 'SEG') {
+      if (segmentationService.getSegmentation(segmentationId)) {
+        return applyRepresentation();
       }
-    );
-    // store the segmentation presentation id in the viewport info
-    this.storePresentation({ viewportId: viewport.id });
-    return segmentationRepresentationPromise;
+
+      // Bound the wait so a failed/aborted SEG load (where SEGMENTATION_LOADING_COMPLETE
+      // never fires) cannot leave this promise — and the viewport setup awaiting it —
+      // hanging indefinitely.
+      const SEG_LOADING_TIMEOUT_MS = 120000;
+
+      return new Promise<void>(resolve => {
+        let settled = false;
+        let timeoutId;
+
+        const settle = () => {
+          settled = true;
+          clearTimeout(timeoutId);
+          unsubscribe();
+          resolve();
+        };
+
+        const { unsubscribe } = segmentationService.subscribe(
+          segmentationService.EVENTS.SEGMENTATION_LOADING_COMPLETE,
+          async (evt: { segDisplaySet?: OhifTypes.DisplaySet }) => {
+            if (settled || evt.segDisplaySet?.displaySetInstanceUID !== segmentationId) {
+              return;
+            }
+
+            settle();
+
+            try {
+              await applyRepresentation();
+            } catch (error) {
+              console.warn(
+                `Failed to apply segmentation representation for "${segmentationId}":`,
+                error
+              );
+            }
+          }
+        );
+
+        // Stop waiting immediately if the SEG load itself fails — otherwise the
+        // loading-complete event never fires and we would idle until the timeout.
+        const loadingPromise = (displaySet as { loadingPromise?: Promise<unknown> })
+          .loadingPromise;
+        loadingPromise?.catch(error => {
+          if (settled) {
+            return;
+          }
+
+          console.warn(
+            `Segmentation "${segmentationId}" failed to load; skipping representation setup.`,
+            error
+          );
+          settle();
+        });
+
+        timeoutId = setTimeout(() => {
+          if (settled) {
+            return;
+          }
+
+          console.warn(
+            `Timed out waiting for segmentation "${segmentationId}" to load; skipping representation setup.`
+          );
+          settle();
+        }, SEG_LOADING_TIMEOUT_MS);
+      });
+    }
+
+    return applyRepresentation();
   }
 
   private async _addOverlayRepresentations(
diff --git a/extensions/cornerstone/src/utils/segmentationHandlers.ts b/extensions/cornerstone/src/utils/segmentationHandlers.ts
index 3b7cd497081..15e02f20299 100644
--- a/extensions/cornerstone/src/utils/segmentationHandlers.ts
+++ b/extensions/cornerstone/src/utils/segmentationHandlers.ts
@@ -53,10 +53,14 @@ export function setupSegmentationDataModifiedHandler({
       });
 
       if (!isUnsubscribed && updatedSegmentation) {
-        segmentationService.addOrUpdateSegmentation({
-          segmentationId,
-          segments: updatedSegmentation.segments,
-        });
+        const existingSegmentation = segmentationService.getSegmentation(segmentationId);
+
+        if (existingSegmentation) {
+          segmentationService.addOrUpdateSegmentation({
+            segmentationId,
+            segments: updatedSegmentation.segments,
+          });
+        }
       }
     },
     1000
diff --git a/extensions/default/package.json b/extensions/default/package.json
index 8a6b49433b1..bfecb836985 100644
--- a/extensions/default/package.json
+++ b/extensions/default/package.json
@@ -31,7 +31,7 @@
   "peerDependencies": {
     "@ohif/core": "workspace:*",
     "@ohif/i18n": "workspace:*",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "dicomweb-client": "0.10.4",
     "prop-types": "15.8.1",
     "react": "18.3.1",
@@ -48,6 +48,7 @@
     "react-color": "2.19.3"
   },
   "devDependencies": {
+    "cross-env": "7.0.3",
     "webpack-merge": "5.10.0"
   },
   "keywords": [
diff --git a/extensions/default/src/DicomLocalDataSource/index.js b/extensions/default/src/DicomLocalDataSource/index.js
index 462fb875113..3ada3776769 100644
--- a/extensions/default/src/DicomLocalDataSource/index.js
+++ b/extensions/default/src/DicomLocalDataSource/index.js
@@ -1,6 +1,11 @@
 import { DicomMetadataStore, IWebApiDataSource, utils } from '@ohif/core';
 import OHIF from '@ohif/core';
-import dcmjs from 'dcmjs';
+import {
+  datasetToDicomBlob,
+  makeExistingPropertiesNonEnumerable,
+  setNonEnumerableInstanceProperty,
+} from '../utils/dicomWriter';
+import { appendFrameQueryToImageId } from '../utils/appendFrameQueryToImageId';
 
 const metadataProvider = OHIF.classes.MetadataProvider;
 const { EVENTS } = DicomMetadataStore;
@@ -152,14 +157,15 @@ function createDicomLocalApi(dicomLocalConfig) {
                 SOPInstanceUID,
               } = instance;
 
-              instance.imageId = imageId;
+              setNonEnumerableInstanceProperty(instance, 'imageId', imageId);
+              makeExistingPropertiesNonEnumerable(instance);
 
               // Add imageId specific mapping to this data as the URL isn't necessarily WADO-URI.
               metadataProvider.addImageIdToUIDs(imageId, {
                 StudyInstanceUID,
                 SeriesInstanceUID,
                 SOPInstanceUID,
-                frameIndex: isMultiframe ? index : 1,
+                frameNumber: isMultiframe ? index + 1 : 1,
               });
             });
 
@@ -174,7 +180,7 @@ function createDicomLocalApi(dicomLocalConfig) {
     },
     store: {
       dicom: naturalizedReport => {
-        const reportBlob = dcmjs.data.datasetToBlob(naturalizedReport);
+        const reportBlob = datasetToDicomBlob(naturalizedReport);
 
         //Create a URL for the binary.
         var objectUrl = URL.createObjectURL(reportBlob);
@@ -211,9 +217,6 @@ function createDicomLocalApi(dicomLocalConfig) {
     getImageIdsForInstance({ instance, frame }) {
       // Important: Never use instance.imageId because it might be multiframe,
       // which would make it an invalid imageId.
-      // if (instance.imageId) {
-      //   return instance.imageId;
-      // }
 
       const { StudyInstanceUID, SeriesInstanceUID } = instance;
       const SOPInstanceUID = instance.SOPInstanceUID || instance.SopInstanceUID;
@@ -223,13 +226,20 @@ function createDicomLocalApi(dicomLocalConfig) {
         SOPInstanceUID
       );
 
-      let imageId = storedInstance.url;
+      const baseImageId = storedInstance?.url || instance.url;
 
-      if (frame !== undefined) {
-        imageId += `&frame=${frame}`;
+      if (!baseImageId) {
+        return;
       }
 
-      return imageId;
+      const numberOfFrames = Number(storedInstance?.NumberOfFrames || instance.NumberOfFrames) || 1;
+
+      if (numberOfFrames > 1) {
+        const frameNumber = frame !== undefined ? frame : 1;
+        return appendFrameQueryToImageId(baseImageId, frameNumber);
+      }
+
+      return baseImageId;
     },
     deleteStudyMetadataPromise() {
       console.log('deleteStudyMetadataPromise not implemented');
diff --git a/extensions/default/src/DicomWebDataSource/index.ts b/extensions/default/src/DicomWebDataSource/index.ts
index 9a4d31d95a8..1db2312094f 100644
--- a/extensions/default/src/DicomWebDataSource/index.ts
+++ b/extensions/default/src/DicomWebDataSource/index.ts
@@ -12,11 +12,17 @@ import dcm4cheeReject from './dcm4cheeReject.js';
 
 import getImageId from './utils/getImageId.js';
 import dcmjs from 'dcmjs';
+import dicomImageLoader from '@cornerstonejs/dicom-image-loader';
 import { retrieveStudyMetadata, deleteStudyMetadataPromise } from './retrieveStudyMetadata.js';
 import StaticWadoClient from './utils/StaticWadoClient';
 import getDirectURL from '../utils/getDirectURL';
 import { fixBulkDataURI } from './utils/fixBulkDataURI';
 import { HeadersInterface } from '@ohif/core/src/types/RequestHeaders';
+import {
+  getDatasetTransferSyntaxUID,
+  setNonEnumerableInstanceProperty,
+  writeDicomDictToPart10Buffer,
+} from '../utils/dicomWriter';
 import { getGetThumbnailSrc, ThumbnailContext } from './retrieveThumbnail';
 import { getRenderedURL } from './retrieveRendered';
 
@@ -26,7 +32,6 @@ const { naturalizeDataset, denaturalizeDataset } = DicomMetaDictionary;
 
 const ImplementationClassUID = '2.25.270695996825855179949881587723571202391.2.0.0';
 const ImplementationVersionName = 'OHIF-3.11.0';
-const EXPLICIT_VR_LITTLE_ENDIAN = '1.2.840.10008.1.2.1';
 
 const metadataProvider = classes.MetadataProvider;
 
@@ -308,6 +313,88 @@ function createDicomWebApi(dicomWebConfig: DicomWebConfig, servicesManager) {
        */
       getWadoDicomWebClient: () => wadoDicomWebClient,
 
+      /**
+       * Best-effort prefetch of a whole multiframe instance as a single Part 10
+       * object, registered into the Cornerstone3D NATURALIZED frame registry so
+       * subsequent per-frame image loads are served locally instead of issuing
+       * one network request per frame (see the "Behaviours" doc
+       * segmentation-multiframe-part10-prefetch).
+       *
+       * Gated by `loadMultiframeAsPart10RaceTimeMs`: 0/undefined disables it.
+       * Never throws into the caller — on any failure it resolves `done` to
+       * `false` and the normal per-frame load path is used.
+       *
+       * @returns `{ done: Promise<boolean>, cancel: () => void }`.
+       */
+      prefetchInstanceFrames: ({
+        instance,
+        imageId,
+        loadMultiframeAsPart10RaceTimeMs,
+      }) => {
+        const noop = { done: Promise.resolve(false), cancel: () => {} };
+
+        if (!loadMultiframeAsPart10RaceTimeMs || !instance || !imageId) {
+          return noop;
+        }
+
+        const StudyInstanceUID = instance.StudyInstanceUID;
+        const SeriesInstanceUID = instance.SeriesInstanceUID;
+        const SOPInstanceUID = instance.SOPInstanceUID || instance.SopInstanceUID;
+
+        if (!StudyInstanceUID || !SeriesInstanceUID || !SOPInstanceUID) {
+          return noop;
+        }
+
+        let cancelled = false;
+
+        // Lazy resolver: dicomweb-client.retrieveInstance returns the Part 10
+        // instance as an ArrayBuffer, unwrapping multipart/related transparently
+        // (and returning the raw object for single-part responses).
+        const resolvePart10 = async () => {
+          wadoDicomWebClient.headers = getAuthorizationHeader();
+          const result = await wadoDicomWebClient.retrieveInstance({
+            studyInstanceUID: StudyInstanceUID,
+            seriesInstanceUID: SeriesInstanceUID,
+            sopInstanceUID: SOPInstanceUID,
+          });
+
+          if (cancelled) {
+            throw new Error('prefetchInstanceFrames cancelled');
+          }
+
+          if (result instanceof ArrayBuffer) {
+            return result;
+          }
+          if (Array.isArray(result) && result[0] instanceof ArrayBuffer) {
+            return result[0];
+          }
+          if (result && (result as { buffer?: ArrayBuffer }).buffer instanceof ArrayBuffer) {
+            return (result as ArrayBufferView).buffer as ArrayBuffer;
+          }
+          throw new Error('Unexpected retrieveInstance result for instance prefetch');
+        };
+
+        const done = (async () => {
+          try {
+            await dicomImageLoader.prefetchPart10Instance(imageId, resolvePart10);
+            return !cancelled;
+          } catch (error) {
+            console.warn(
+              '[prefetchInstanceFrames] full-instance prefetch failed; falling back to per-frame loads',
+              error
+            );
+            return false;
+          }
+        })();
+
+        return {
+          done,
+          cancel: () => {
+            cancelled = true;
+          },
+        };
+      },
+
       bulkDataURI: async ({ StudyInstanceUID, BulkDataURI }) => {
         qidoDicomWebClient.headers = getAuthorizationHeader();
         const options = {
@@ -372,7 +459,7 @@ function createDicomWebApi(dicomWebConfig: DicomWebConfig, servicesManager) {
               FileMetaInformationVersion: dataset._meta?.FileMetaInformationVersion?.Value,
               MediaStorageSOPClassUID: dataset.SOPClassUID,
               MediaStorageSOPInstanceUID: dataset.SOPInstanceUID,
-              TransferSyntaxUID: EXPLICIT_VR_LITTLE_ENDIAN,
+              TransferSyntaxUID: getDatasetTransferSyntaxUID(dataset),
               ImplementationClassUID,
               ImplementationVersionName,
             };
@@ -384,7 +471,7 @@ function createDicomWebApi(dicomWebConfig: DicomWebConfig, servicesManager) {
             effectiveDicomDict = defaultDicomDict;
           }
 
-          const part10Buffer = effectiveDicomDict.write();
+          const part10Buffer = writeDicomDictToPart10Buffer(effectiveDicomDict);
 
           const options = {
             datasets: [part10Buffer],
@@ -445,9 +532,9 @@ function createDicomWebApi(dicomWebConfig: DicomWebConfig, servicesManager) {
           instance,
         });
 
-        instance.imageId = imageId;
-        instance.wadoRoot = dicomWebConfig.wadoRoot;
-        instance.wadoUri = dicomWebConfig.wadoUri;
+        setNonEnumerableInstanceProperty(instance, 'imageId', imageId);
+        setNonEnumerableInstanceProperty(instance, 'wadoRoot', dicomWebConfig.wadoRoot);
+        setNonEnumerableInstanceProperty(instance, 'wadoUri', dicomWebConfig.wadoUri);
 
         metadataProvider.addImageIdToUIDs(imageId, {
           StudyInstanceUID,
@@ -544,8 +631,8 @@ function createDicomWebApi(dicomWebConfig: DicomWebConfig, servicesManager) {
 
         // Adding instanceMetadata to OHIF MetadataProvider
         naturalizedInstances.forEach(instance => {
-          instance.wadoRoot = dicomWebConfig.wadoRoot;
-          instance.wadoUri = dicomWebConfig.wadoUri;
+          setNonEnumerableInstanceProperty(instance, 'wadoRoot', dicomWebConfig.wadoRoot);
+          setNonEnumerableInstanceProperty(instance, 'wadoUri', dicomWebConfig.wadoUri);
 
           const { StudyInstanceUID, SeriesInstanceUID, SOPInstanceUID } = instance;
           const numberOfFrames = instance.NumberOfFrames || 1;
@@ -571,7 +658,7 @@ function createDicomWebApi(dicomWebConfig: DicomWebConfig, servicesManager) {
           const imageId = implementation.getImageIdsForInstance({
             instance,
           });
-          instance.imageId = imageId;
+          setNonEnumerableInstanceProperty(instance, 'imageId', imageId);
         });
 
         DicomMetadataStore.addInstances(naturalizedInstances, madeInClient);
diff --git a/extensions/default/src/commandsModule.ts b/extensions/default/src/commandsModule.ts
index 2442ce66a7b..40ef854d920 100644
--- a/extensions/default/src/commandsModule.ts
+++ b/extensions/default/src/commandsModule.ts
@@ -1,5 +1,6 @@
 import { Types, DicomMetadataStore, utils } from '@ohif/core';
-import dcmjs from 'dcmjs';
+import { datasetToDicomBlob, setNonEnumerableInstanceProperty } from './utils/dicomWriter';
+import { registerNaturalizedDatasetsForLocalWadouri } from './utils/registerNaturalizedDatasetForLocalWadouri';
 
 const { downloadBlob } = utils;
 
@@ -784,11 +785,12 @@ const commandsModule = ({
       if (dataSource === 'download') {
         return async dicom => {
           const instances = Array.isArray(dicom) ? dicom : [dicom];
+          registerNaturalizedDatasetsForLocalWadouri(instances);
           DicomMetadataStore.addInstances(instances, true);
           if (instances.length !== 1) {
             throw new Error('Download only supports a single DICOM instance');
           }
-          const reportBlob = dcmjs.data.datasetToBlob(instances[0]);
+          const reportBlob = datasetToDicomBlob(instances[0]);
           downloadBlob(reportBlob, { filename: defaultFileName || 'dicom.dcm' });
         };
       }
@@ -796,14 +798,15 @@ const commandsModule = ({
       if (dataSource === 'copyToClipboard') {
         return async dicom => {
           const instances = Array.isArray(dicom) ? dicom : [dicom];
+          registerNaturalizedDatasetsForLocalWadouri(instances);
           DicomMetadataStore.addInstances(instances, true);
           if (instances.length !== 1) {
             throw new Error('Copy to clipboard only supports a single DICOM instance');
           }
-          const reportBlob = dcmjs.data.datasetToBlob(instances[0]);
+          const reportBlob = datasetToDicomBlob(instances[0]);
           const type = defaultContentType || 'application/dicom';
           await navigator.clipboard.write([
-            new ClipboardItem({ [type]: new Blob([reportBlob], { type }) }),
+            new ClipboardItem({ [type]: reportBlob }),
           ]);
         };
       }
@@ -817,12 +820,18 @@ const commandsModule = ({
 
       return async (dicom, { dicomDict } = {}) => {
         const instances = Array.isArray(dicom) ? dicom : [dicom];
-        const config = resolvedDataSource.getConfig?.();
-        if (config?.wadoRoot) {
-          instances.forEach(instance => {
-            instance.wadoRoot = config.wadoRoot;
-          });
+        // Always keep an in-memory wadouri copy so DICOM can be read without re-fetching.
+        registerNaturalizedDatasetsForLocalWadouri(instances);
+
+        if (dataSource !== 'dicomlocal') {
+          const config = resolvedDataSource.getConfig?.();
+          if (config?.wadoRoot) {
+            instances.forEach(instance => {
+              setNonEnumerableInstanceProperty(instance, 'wadoRoot', config.wadoRoot);
+            });
+          }
         }
+
         DicomMetadataStore.addInstances(instances, true);
         for (const instance of instances) {
           await resolvedDataSource.store.dicom(instance, null, dicomDict);
diff --git a/extensions/default/src/customizations/reportDialogCustomization.tsx b/extensions/default/src/customizations/reportDialogCustomization.tsx
index 3ac79db9861..fc193a7345b 100644
--- a/extensions/default/src/customizations/reportDialogCustomization.tsx
+++ b/extensions/default/src/customizations/reportDialogCustomization.tsx
@@ -10,6 +10,18 @@ type DataSource = {
   placeHolder: string;
 };
 
+/** Radix Select item value for "Create new series" (state remains null). */
+const NEW_SERIES_SELECT_VALUE = '__new_series_id__';
+
+type SeriesOption = {
+  optionKey: string;
+  selectValue: string;
+  value: string | null;
+  seriesNumber: number;
+  description: string | null;
+  label: string;
+};
+
 type ReportDialogProps = {
   dataSources: DataSource[];
   modality?: string;
@@ -46,20 +58,32 @@ function ReportDialog({
   const [selectedSeries, setSelectedSeries] = useState<string | null>(predecessorImageId || null);
   const [reportName, setReportName] = useState('');
 
-  const seriesOptions = useMemo(() => {
+  const seriesOptions = useMemo((): SeriesOption[] => {
     const displaySetsMap = displaySetService.getDisplaySetCache();
     const displaySets = Array.from(displaySetsMap.values());
     const options = displaySets
       .filter(ds => ds.Modality === modality)
-      .map(ds => ({
-        value: ds.predecessorImageId || ds.SeriesInstanceUID,
-        seriesNumber: isFinite(ds.SeriesNumber) ? ds.SeriesNumber : minSeriesNumber,
-        description: ds.SeriesDescription,
-        label: `${ds.SeriesDescription} ${ds.SeriesDate}/${ds.SeriesTime} ${ds.SeriesNumber}`,
-      }));
+      .map(ds => {
+        const value = ds.predecessorImageId || ds.SeriesInstanceUID;
+        const selectValue = value || ds.displaySetInstanceUID;
+        return {
+          optionKey: `series-${ds.displaySetInstanceUID}`,
+          selectValue,
+          value: value || null,
+          seriesNumber: isFinite(ds.SeriesNumber) ? ds.SeriesNumber : minSeriesNumber,
+          description: ds.SeriesDescription,
+          label: `${ds.SeriesDescription} ${ds.SeriesDate}/${ds.SeriesTime} ${ds.SeriesNumber}`,
+        };
+      })
+      .filter(
+        option =>
+          option.selectValue && option.selectValue !== NEW_SERIES_SELECT_VALUE
+      );
 
     return [
       {
+        optionKey: NEW_SERIES_SELECT_VALUE,
+        selectValue: NEW_SERIES_SELECT_VALUE,
         value: null,
         description: null,
         seriesNumber: minSeriesNumber,
@@ -67,7 +91,17 @@ function ReportDialog({
       },
       ...options,
     ];
-  }, [displaySetService, modality]);
+  }, [displaySetService, modality, minSeriesNumber]);
+
+  const handleSeriesChange = useCallback(
+    (selectValue: string) => {
+      const option = seriesOptions.find(o => o.selectValue === selectValue);
+      setSelectedSeries(
+        selectValue === NEW_SERIES_SELECT_VALUE ? null : (option?.value ?? selectValue)
+      );
+    },
+    [seriesOptions]
+  );
 
   useEffect(() => {
     const seriesOption = seriesOptions.find(s => s.value === selectedSeries);
@@ -115,6 +149,11 @@ function ReportDialog({
 
   const showDataSourceSelect = dataSources?.length > 1;
   const showDownloadButton = enableDownload;
+  const selectedSeriesSelectValue =
+    selectedSeries == null
+      ? NEW_SERIES_SELECT_VALUE
+      : (seriesOptions.find(o => o.value === selectedSeries)?.selectValue ??
+        selectedSeries);
 
   return (
     <div className="text-foreground flex min-w-[400px] max-w-md flex-col">
@@ -146,8 +185,8 @@ function ReportDialog({
               <div className={showDataSourceSelect ? 'mt-1 w-1/2' : 'mt-1 w-full'}>
                 <div className="mb-1 pl-1 text-base">Series</div>
                 <Select
-                  value={selectedSeries}
-                  onValueChange={setSelectedSeries}
+                  value={selectedSeriesSelectValue}
+                  onValueChange={handleSeriesChange}
                 >
                   <SelectTrigger>
                     <SelectValue placeholder="Select a series" />
@@ -155,8 +194,8 @@ function ReportDialog({
                   <SelectContent>
                     {seriesOptions.map(series => (
                       <SelectItem
-                        key={series.value}
-                        value={series.value}
+                        key={series.optionKey}
+                        value={series.selectValue}
                       >
                         {series.label}
                       </SelectItem>
@@ -172,8 +211,8 @@ function ReportDialog({
             <div className="w-1/3">
               <div className="mb-1 pl-1 text-base">Series</div>
               <Select
-                value={selectedSeries}
-                onValueChange={setSelectedSeries}
+                value={selectedSeriesSelectValue}
+                onValueChange={handleSeriesChange}
               >
                 <SelectTrigger>
                   <SelectValue placeholder="Select a series" />
@@ -181,8 +220,8 @@ function ReportDialog({
                 <SelectContent>
                   {seriesOptions.map(series => (
                     <SelectItem
-                      key={series.value}
-                      value={series.value}
+                      key={series.optionKey}
+                      value={series.selectValue}
                     >
                       {series.label}
                     </SelectItem>
diff --git a/extensions/default/src/utils/appendFrameQueryToImageId.js b/extensions/default/src/utils/appendFrameQueryToImageId.js
new file mode 100644
index 00000000000..22190cc6cf3
--- /dev/null
+++ b/extensions/default/src/utils/appendFrameQueryToImageId.js
@@ -0,0 +1,9 @@
+/**
+ * Appends ?frame= or &frame= to a local/wadouri imageId.
+ */
+export function appendFrameQueryToImageId(baseImageId, frame) {
+  const withoutFrame = baseImageId.split('&frame=')[0].split('?frame=')[0];
+  const separator = withoutFrame.includes('?') ? '&' : '?';
+
+  return `${withoutFrame}${separator}frame=${frame}`;
+}
diff --git a/extensions/default/src/utils/dicomWriter.test.ts b/extensions/default/src/utils/dicomWriter.test.ts
new file mode 100644
index 00000000000..74bd4f58f1a
--- /dev/null
+++ b/extensions/default/src/utils/dicomWriter.test.ts
@@ -0,0 +1,127 @@
+import { TextEncoder, TextDecoder } from 'util';
+import dcmjs from 'dcmjs';
+import { DICOM_WRITE_OPTIONS, writeDicomDictToPart10Buffer } from './dicomWriter';
+
+// jsdom does not expose TextEncoder/TextDecoder, which dcmjs's buffer streams need.
+if (typeof (global as { TextEncoder?: unknown }).TextEncoder === 'undefined') {
+  (global as { TextEncoder?: unknown }).TextEncoder = TextEncoder;
+}
+if (typeof (global as { TextDecoder?: unknown }).TextDecoder === 'undefined') {
+  (global as { TextDecoder?: unknown }).TextDecoder = TextDecoder;
+}
+
+const RLE_LOSSLESS = '1.2.840.10008.1.2.5';
+const EXPLICIT_VR_LITTLE_ENDIAN = '1.2.840.10008.1.2.1';
+const PIXEL_DATA_TAG = '7FE00010';
+
+// Use frames larger than dcmjs's 20KB fragment size so that, if a frame were
+// ever split, we'd see more than one fragment per frame.
+const FRAME_BYTES = 30000;
+
+function makeDicomDict(transferSyntaxUID, vr, pixelDataValue) {
+  const dict = new dcmjs.data.DicomDict({
+    '00020010': { vr: 'UI', Value: [transferSyntaxUID] },
+    '00020002': { vr: 'UI', Value: ['1.2.840.10008.5.1.4.1.1.66.4'] },
+    '00020003': { vr: 'UI', Value: ['1.2.3.4.5'] },
+  });
+  dict.upsertTag(PIXEL_DATA_TAG, vr, pixelDataValue);
+  return dict;
+}
+
+/**
+ * Locates the PixelData element in a Part-10 buffer and, when it is encapsulated,
+ * walks the encapsulated items (Basic Offset Table + fragments).
+ */
+function inspectPixelData(arrayBuffer) {
+  const dv = new DataView(arrayBuffer);
+
+  // Skip the 128-byte preamble + "DICM", then read the file-meta group length
+  // from (0002,0000) UL to find where the dataset begins.
+  const metaGroupLength = dv.getUint32(140, true);
+  let offset = 144 + metaGroupLength;
+
+  // PixelData (7FE0,0010), explicit VR (OB/OW) — long form: VR(2) + reserved(2) + length(4).
+  const group = dv.getUint16(offset, true);
+  const element = dv.getUint16(offset + 2, true);
+  if (group !== 0x7fe0 || element !== 0x0010) {
+    throw new Error(
+      `Expected PixelData at offset ${offset}, found ${group.toString(16)},${element.toString(16)}`
+    );
+  }
+
+  const length = dv.getUint32(offset + 8, true);
+  if (length !== 0xffffffff) {
+    return { encapsulated: false, length };
+  }
+
+  // Encapsulated: first item is the Basic Offset Table, then one item per fragment,
+  // terminated by the Sequence Delimitation Item (FFFE,E0DD).
+  let p = offset + 12;
+  const itemSizes: number[] = [];
+
+  while (p + 8 <= dv.byteLength) {
+    const itemGroup = dv.getUint16(p, true);
+    const itemElement = dv.getUint16(p + 2, true);
+    const itemLength = dv.getUint32(p + 4, true);
+    p += 8;
+
+    if (itemGroup === 0xfffe && itemElement === 0xe0dd) {
+      break; // sequence delimiter
+    }
+    if (itemGroup !== 0xfffe || itemElement !== 0xe000) {
+      throw new Error(`Unexpected item tag at ${p - 8}`);
+    }
+
+    itemSizes.push(itemLength);
+    p += itemLength;
+  }
+
+  // itemSizes[0] is the Basic Offset Table; the rest are frame fragments.
+  return {
+    encapsulated: true,
+    totalItems: itemSizes.length,
+    basicOffsetTableSize: itemSizes[0],
+    fragmentSizes: itemSizes.slice(1),
+  };
+}
+
+describe('dicomWriter DICOM_WRITE_OPTIONS fragmentation', () => {
+  it('writes exactly one fragment per frame (plus the Basic Offset Table) for compressed pixel data', () => {
+    const frames = [new Uint8Array(FRAME_BYTES).buffer, new Uint8Array(FRAME_BYTES).buffer];
+    const dict = makeDicomDict(RLE_LOSSLESS, 'OB', frames);
+
+    const buffer = writeDicomDictToPart10Buffer(dict);
+    const result = inspectPixelData(buffer);
+
+    expect(result.encapsulated).toBe(true);
+    // 1 Basic Offset Table item + 1 fragment per frame.
+    expect(result.totalItems).toBe(frames.length + 1);
+    expect(result.fragmentSizes).toHaveLength(frames.length);
+    // Each frame stayed in a single fragment despite exceeding the 20KB fragment size.
+    result.fragmentSizes.forEach(size => expect(size).toBe(FRAME_BYTES));
+  });
+
+  it('does not fragment uncompressed pixel data', () => {
+    const pixelData = new Uint16Array(FRAME_BYTES).buffer;
+    const dict = makeDicomDict(EXPLICIT_VR_LITTLE_ENDIAN, 'OW', [pixelData]);
+
+    const buffer = writeDicomDictToPart10Buffer(dict);
+    const result = inspectPixelData(buffer);
+
+    expect(result.encapsulated).toBe(false);
+    expect(result.length).toBe(pixelData.byteLength);
+  });
+
+  it('confirms fragmentMultiframe:false is what prevents a single large frame from splitting', () => {
+    // Control: with fragmentMultiframe enabled, a >20KB frame splits into multiple
+    // fragments — proving DICOM_WRITE_OPTIONS.fragmentMultiframe:false is meaningful.
+    const frames = [new Uint8Array(FRAME_BYTES).buffer];
+    const dict = makeDicomDict(RLE_LOSSLESS, 'OB', frames);
+
+    const buffer = dict.write({ ...DICOM_WRITE_OPTIONS, fragmentMultiframe: true });
+    const result = inspectPixelData(buffer);
+
+    expect(result.encapsulated).toBe(true);
+    expect(result.fragmentSizes.length).toBeGreaterThan(1);
+  });
+});
diff --git a/extensions/default/src/utils/dicomWriter.ts b/extensions/default/src/utils/dicomWriter.ts
new file mode 100644
index 00000000000..b42a0f63310
--- /dev/null
+++ b/extensions/default/src/utils/dicomWriter.ts
@@ -0,0 +1,109 @@
+import dcmjs from 'dcmjs';
+
+export const EXPLICIT_VR_LITTLE_ENDIAN = '1.2.840.10008.1.2.1';
+
+export const DICOM_WRITE_OPTIONS = {
+  allowInvalidVRLength: false,
+  // `fragmentMultiframe` only governs whether a SINGLE frame is split across
+  // multiple fragments (dcmjs splits frames larger than its 20KB fragment size).
+  // It does NOT merge frames: in an encapsulated (compressed) transfer syntax
+  // every frame is always written as its own fragment, preceded by the Basic
+  // Offset Table; in an uncompressed syntax pixel data is never fragmented at
+  // all. Keeping this `false` therefore yields exactly one fragment per frame
+  // for compressed SEG — the conformant layout — without splitting large frames.
+  fragmentMultiframe: false,
+};
+
+/** OHIF runtime fields — not DICOM tags; must not be enumerable for dcmjs datasetToDict. */
+export const RUNTIME_INSTANCE_PROPERTY_KEYS = [
+  'url',
+  'wadorsuri',
+  'wadouri',
+  'wadoRoot',
+  'wadoUri',
+  'wadoUriRoot',
+  'imageRendering',
+  'imageId',
+  '_parentInstance',
+  'frameNumber',
+] as const;
+
+/**
+ * Attaches OHIF runtime data on an instance without enumerable keys (safe for dcmjs datasetToDict).
+ */
+export function setNonEnumerableInstanceProperty(
+  instance: Record<string, unknown>,
+  key: string,
+  value: unknown
+) {
+  Object.defineProperty(instance, key, {
+    value,
+    enumerable: false,
+    writable: true,
+    configurable: true,
+  });
+}
+
+/**
+ * Re-defines any existing enumerable runtime properties as non-enumerable (keeps values).
+ */
+export function makeExistingPropertiesNonEnumerable(instance: Record<string, unknown>) {
+  for (const key of RUNTIME_INSTANCE_PROPERTY_KEYS) {
+    if (!Object.prototype.hasOwnProperty.call(instance, key)) {
+      continue;
+    }
+
+    const descriptor = Object.getOwnPropertyDescriptor(instance, key);
+
+    if (!descriptor || descriptor.enumerable === false) {
+      continue;
+    }
+
+    setNonEnumerableInstanceProperty(instance, key, descriptor.value);
+  }
+}
+
+export function getDatasetTransferSyntaxUID(dataset) {
+  const fromMeta = dataset?._meta?.TransferSyntaxUID;
+
+  if (typeof fromMeta === 'string') {
+    return fromMeta;
+  }
+
+  if (Array.isArray(fromMeta?.Value)) {
+    return fromMeta.Value[0];
+  }
+
+  if (typeof dataset?.TransferSyntaxUID === 'string') {
+    return dataset.TransferSyntaxUID;
+  }
+
+  return EXPLICIT_VR_LITTLE_ENDIAN;
+}
+
+function applyTransferSyntaxToFileMeta(dicomDict, transferSyntaxUID) {
+  if (!transferSyntaxUID || !dicomDict?.meta) {
+    return;
+  }
+
+  const entry = { vr: 'UI', Value: [transferSyntaxUID] };
+  dicomDict.meta.TransferSyntaxUID = entry;
+  dicomDict.meta['00020010'] = entry;
+}
+
+export function datasetToDicomPart10Buffer(dataset) {
+  makeExistingPropertiesNonEnumerable(dataset);
+  const transferSyntaxUID = getDatasetTransferSyntaxUID(dataset);
+  const dicomDict = dcmjs.data.datasetToDict(dataset);
+  applyTransferSyntaxToFileMeta(dicomDict, transferSyntaxUID);
+  return dicomDict.write(DICOM_WRITE_OPTIONS);
+}
+
+export function datasetToDicomBlob(dataset) {
+  const part10Buffer = datasetToDicomPart10Buffer(dataset);
+  return new Blob([part10Buffer], { type: 'application/dicom' });
+}
+
+export function writeDicomDictToPart10Buffer(dicomDict) {
+  return dicomDict.write(DICOM_WRITE_OPTIONS);
+}
diff --git a/extensions/default/src/utils/registerNaturalizedDatasetForLocalWadouri.js b/extensions/default/src/utils/registerNaturalizedDatasetForLocalWadouri.js
new file mode 100644
index 00000000000..675a33438ab
--- /dev/null
+++ b/extensions/default/src/utils/registerNaturalizedDatasetForLocalWadouri.js
@@ -0,0 +1,93 @@
+import dicomImageLoader from '@cornerstonejs/dicom-image-loader';
+import OHIF from '@ohif/core';
+
+import {
+  datasetToDicomBlob,
+  makeExistingPropertiesNonEnumerable,
+  setNonEnumerableInstanceProperty,
+} from './dicomWriter';
+import { appendFrameQueryToImageId } from './appendFrameQueryToImageId';
+
+const metadataProvider = OHIF.classes.MetadataProvider;
+
+const SEG_REGISTER_LOG_PREFIX = '[SEG register]';
+
+/**
+ * Registers a naturalized DICOM dataset with the wadouri file manager so it can be
+ * loaded like other locally stored instances (blob URL), instead of remote wadors URLs.
+ *
+ * @param {object} dataset - Naturalized DICOM instance (e.g. generated SEG).
+ * @param {object} [options]
+ * @param {string[]} [options.referencedImageIds] - Used for logging / frame count hints.
+ * @returns {string} wadouri imageId assigned to dataset.url
+ */
+export function registerNaturalizedDatasetForLocalWadouri(dataset, options = {}) {
+  const { referencedImageIds = [] } = options;
+  const blob = datasetToDicomBlob(dataset);
+  const imageId = dicomImageLoader.wadouri.fileManager.add(blob);
+
+  setNonEnumerableInstanceProperty(dataset, 'url', imageId);
+
+  const { StudyInstanceUID, SeriesInstanceUID } = dataset;
+  const SOPInstanceUID = dataset.SOPInstanceUID || dataset.SopInstanceUID;
+
+  const perFrameGroups = dataset.PerFrameFunctionalGroupsSequence;
+  if (Array.isArray(perFrameGroups) && !dataset.NumberOfFrames) {
+    dataset.NumberOfFrames = perFrameGroups.length;
+  }
+
+  const numberOfFrames = Math.max(
+    Number(dataset.NumberOfFrames) || 0,
+    Array.isArray(perFrameGroups) ? perFrameGroups.length : 0,
+    1
+  );
+  dataset.NumberOfFrames = numberOfFrames;
+
+  const frameImageIds = [];
+  if (StudyInstanceUID && SeriesInstanceUID && SOPInstanceUID) {
+    const registerMapping = (id, frameNumber = 1) => {
+      metadataProvider.addImageIdToUIDs(id, {
+        StudyInstanceUID,
+        SeriesInstanceUID,
+        SOPInstanceUID,
+        frameNumber,
+      });
+    };
+
+    for (let frame = 1; frame <= numberOfFrames; frame++) {
+      const frameImageId =
+        numberOfFrames > 1 ? appendFrameQueryToImageId(imageId, frame) : imageId;
+
+      frameImageIds.push(frameImageId);
+      registerMapping(frameImageId, frame);
+    }
+  }
+
+  makeExistingPropertiesNonEnumerable(dataset);
+
+  OHIF.log.debug(SEG_REGISTER_LOG_PREFIX, 'Registered local wadouri instance', {
+    StudyInstanceUID,
+    SeriesInstanceUID,
+    SOPInstanceUID,
+    numberOfFrames,
+    baseImageId: imageId,
+    frameImageIds,
+    blobSizeBytes: blob.size,
+    referencedImageIdCount: referencedImageIds.length,
+    SegmentationType: dataset.SegmentationType,
+    SOPClassUID: dataset.SOPClassUID,
+  });
+
+  return imageId;
+}
+
+export function registerNaturalizedDatasetsForLocalWadouri(instances, options = {}) {
+  const list = Array.isArray(instances) ? instances : [instances];
+  const { referencedImageIds = [] } = options;
+
+  list.forEach(instance =>
+    registerNaturalizedDatasetForLocalWadouri(instance, { referencedImageIds })
+  );
+
+  return list;
+}
diff --git a/extensions/dicom-pdf/package.json b/extensions/dicom-pdf/package.json
index 92a10131086..093e0bde75f 100644
--- a/extensions/dicom-pdf/package.json
+++ b/extensions/dicom-pdf/package.json
@@ -30,7 +30,7 @@
   "peerDependencies": {
     "@ohif/core": "workspace:*",
     "@ohif/ui": "workspace:*",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "dicom-parser": "1.8.21",
     "hammerjs": "2.0.8",
     "prop-types": "15.8.1",
diff --git a/extensions/dicom-video/package.json b/extensions/dicom-video/package.json
index fac25b531e9..0cde1d6cd5a 100644
--- a/extensions/dicom-video/package.json
+++ b/extensions/dicom-video/package.json
@@ -30,7 +30,7 @@
   "peerDependencies": {
     "@ohif/core": "workspace:*",
     "@ohif/ui": "workspace:*",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "dicom-parser": "1.8.21",
     "hammerjs": "2.0.8",
     "prop-types": "15.8.1",
diff --git a/extensions/measurement-tracking/package.json b/extensions/measurement-tracking/package.json
index bb4b3f23161..7b90c483e89 100644
--- a/extensions/measurement-tracking/package.json
+++ b/extensions/measurement-tracking/package.json
@@ -34,7 +34,7 @@
     "@ohif/extension-default": "workspace:*",
     "@ohif/ui": "workspace:*",
     "classnames": "2.5.1",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "lodash.debounce": "4.0.8",
     "prop-types": "15.8.1",
     "react": "18.3.1",
@@ -48,6 +48,7 @@
     "xstate": "4.38.3"
   },
   "devDependencies": {
+    "cross-env": "7.0.3",
     "webpack-merge": "5.10.0"
   },
   "keywords": [
diff --git a/extensions/test-extension/package.json b/extensions/test-extension/package.json
index c388d4117e0..f2607b6dbe4 100644
--- a/extensions/test-extension/package.json
+++ b/extensions/test-extension/package.json
@@ -30,7 +30,7 @@
   "peerDependencies": {
     "@ohif/core": "workspace:*",
     "@ohif/ui": "workspace:*",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "dicom-parser": "1.8.21",
     "hammerjs": "2.0.8",
     "prop-types": "15.8.1",
diff --git a/extensions/tmtv/package.json b/extensions/tmtv/package.json
index 116344bb683..2b61bb9dae7 100644
--- a/extensions/tmtv/package.json
+++ b/extensions/tmtv/package.json
@@ -30,7 +30,7 @@
   "peerDependencies": {
     "@ohif/core": "workspace:*",
     "@ohif/ui": "workspace:*",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "dicom-parser": "1.8.21",
     "hammerjs": "2.0.8",
     "prop-types": "15.8.1",
diff --git a/modes/basic-dev-mode/package.json b/modes/basic-dev-mode/package.json
index 8c1a4f4c458..b7b7052cdf2 100644
--- a/modes/basic-dev-mode/package.json
+++ b/modes/basic-dev-mode/package.json
@@ -41,6 +41,7 @@
     "i18next": "17.3.1"
   },
   "devDependencies": {
+    "cross-env": "7.0.3",
     "webpack-merge": "5.10.0"
   }
 }
diff --git a/modes/basic-test-mode/package.json b/modes/basic-test-mode/package.json
index 41ef7fa848e..6011fc5bf1a 100644
--- a/modes/basic-test-mode/package.json
+++ b/modes/basic-test-mode/package.json
@@ -43,6 +43,7 @@
     "i18next": "17.3.1"
   },
   "devDependencies": {
+    "cross-env": "7.0.3",
     "webpack-merge": "5.10.0"
   },
   "keywords": [
diff --git a/modes/basic/package.json b/modes/basic/package.json
index 0d68f86d45a..d724f43ec4d 100644
--- a/modes/basic/package.json
+++ b/modes/basic/package.json
@@ -38,6 +38,7 @@
     "@babel/runtime": "7.29.7"
   },
   "devDependencies": {
+    "cross-env": "7.0.3",
     "webpack-merge": "5.10.0"
   },
   "keywords": [
diff --git a/modes/longitudinal/package.json b/modes/longitudinal/package.json
index ce80e8ae576..42ea7cb8f4c 100644
--- a/modes/longitudinal/package.json
+++ b/modes/longitudinal/package.json
@@ -45,6 +45,7 @@
     "i18next": "17.3.1"
   },
   "devDependencies": {
+    "cross-env": "7.0.3",
     "webpack-merge": "5.10.0"
   },
   "keywords": [
diff --git a/modes/tmtv/package.json b/modes/tmtv/package.json
index 226809dc746..a0a6bdedd72 100644
--- a/modes/tmtv/package.json
+++ b/modes/tmtv/package.json
@@ -42,6 +42,7 @@
     "i18next": "17.3.1"
   },
   "devDependencies": {
+    "cross-env": "7.0.3",
     "webpack-merge": "5.10.0"
   },
   "keywords": [
diff --git a/platform/app/package.json b/platform/app/package.json
index 636f263ee28..a980e65e175 100644
--- a/platform/app/package.json
+++ b/platform/app/package.json
@@ -62,7 +62,7 @@
     "classnames": "2.5.1",
     "core-js": "3.45.1",
     "cornerstone-math": "0.1.10",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "detect-gpu": "4.0.50",
     "dicom-parser": "1.8.21",
     "file-loader": "6.2.0",
diff --git a/platform/app/public/config/default.js b/platform/app/public/config/default.js
index 990de73249a..a9196485848 100644
--- a/platform/app/public/config/default.js
+++ b/platform/app/public/config/default.js
@@ -22,7 +22,13 @@ window.config = {
   // whiteLabeling: {},
   extensions: [],
   modes: [],
-  customizationService: {},
+  customizationService: {
+    // SEG store encoding. Labelmap + RLE Lossless is the intended default;
+    // the bitmap modes and the uncompressed Explicit VR Little Endian transfer
+    // syntax exist mainly for testing and are configured per-deployment when needed.
+    'segmentation.store.defaultMode': 'labelmap',
+    'segmentation.store.transferSyntaxUID': '1.2.840.10008.1.2.5',
+  },
 
   // --- URL-driven customizations (?customization=) ----------------------------
   // OFF by default. To allow loading customization data files from the URL, set
@@ -37,7 +43,6 @@ window.config = {
   //   '/remote/': 'https://cdn.example.com/ohif-custom/', // ?customization=/remote/siteA
   // },
   // ----------------------------------------------------------------------------
-
   showStudyList: true,
   // some windows systems have issues with more than 3 web workers
   maxNumberOfWebWorkers: 3,
@@ -80,6 +85,10 @@ window.config = {
         supportsFuzzyMatching: true,
         supportsWildcard: true,
         staticWado: true,
+        // Static WADO has no efficient per-frame endpoint, so for multiframe
+        // SEG, fetch the whole instance once and serve frames from the registry.
+        // Value is the max ms to wait for that fetch before proceeding (0 = off).
+        loadMultiframeAsPart10RaceTimeMs: 3000,
         singlepart: 'bulkdata,video',
         bulkDataURI: {
           enabled: true,
diff --git a/platform/app/public/config/e2e.js b/platform/app/public/config/e2e.js
index 9093acf48d6..71550187263 100644
--- a/platform/app/public/config/e2e.js
+++ b/platform/app/public/config/e2e.js
@@ -112,6 +112,10 @@ window.config = {
         friendlyName: 'StaticWado test data',
         // The most important field to set for static WADO
         staticWado: true,
+        // Static WADO has no efficient per-frame endpoint, so for multiframe
+        // SEG, fetch the whole instance once and serve frames from the registry.
+        // Value is the max ms to wait for that fetch before proceeding (0 = off).
+        loadMultiframeAsPart10RaceTimeMs: 3000,
         name: 'StaticWADO',
         wadoUriRoot: '/viewer-testdata',
         qidoRoot: '/viewer-testdata',
@@ -149,6 +153,10 @@ window.config = {
         supportsFuzzyMatching: false,
         supportsWildcard: true,
         staticWado: true,
+        // Static WADO has no efficient per-frame endpoint, so for multiframe
+        // SEG, fetch the whole instance once and serve frames from the registry.
+        // Value is the max ms to wait for that fetch before proceeding (0 = off).
+        loadMultiframeAsPart10RaceTimeMs: 3000,
         singlepart: 'video',
         bulkDataURI: {
           enabled: true,
@@ -173,6 +181,10 @@ window.config = {
         supportsFuzzyMatching: false,
         supportsWildcard: true,
         staticWado: true,
+        // Static WADO has no efficient per-frame endpoint, so for multiframe
+        // SEG, fetch the whole instance once and serve frames from the registry.
+        // Value is the max ms to wait for that fetch before proceeding (0 = off).
+        loadMultiframeAsPart10RaceTimeMs: 3000,
         singlepart: 'bulkdata,video,pdf',
         bulkDataURI: {
           enabled: true,
@@ -196,6 +208,10 @@ window.config = {
         supportsFuzzyMatching: false,
         supportsWildcard: true,
         staticWado: true,
+        // Static WADO has no efficient per-frame endpoint, so for multiframe
+        // SEG, fetch the whole instance once and serve frames from the registry.
+        // Value is the max ms to wait for that fetch before proceeding (0 = off).
+        loadMultiframeAsPart10RaceTimeMs: 3000,
         singlepart: 'video,pdf',
         bulkDataURI: {
           enabled: true,
@@ -222,6 +238,10 @@ window.config = {
         supportsFuzzyMatching: false,
         supportsWildcard: true,
         staticWado: true,
+        // Static WADO has no efficient per-frame endpoint, so for multiframe
+        // SEG, fetch the whole instance once and serve frames from the registry.
+        // Value is the max ms to wait for that fetch before proceeding (0 = off).
+        loadMultiframeAsPart10RaceTimeMs: 3000,
         singlepart: 'bulkdata,video',
         // whether the data source should use retrieveBulkData to grab metadata,
         // and in case of relative path, what would it be relative to, options
@@ -250,6 +270,10 @@ window.config = {
         supportsFuzzyMatching: false,
         supportsWildcard: true,
         staticWado: true,
+        // Static WADO has no efficient per-frame endpoint, so for multiframe
+        // SEG, fetch the whole instance once and serve frames from the registry.
+        // Value is the max ms to wait for that fetch before proceeding (0 = off).
+        loadMultiframeAsPart10RaceTimeMs: 3000,
         singlepart: 'bulkdata,video',
         // whether the data source should use retrieveBulkData to grab metadata,
         // and in case of relative path, what would it be relative to, options
@@ -279,6 +303,10 @@ window.config = {
         supportsFuzzyMatching: false,
         supportsWildcard: true,
         staticWado: true,
+        // Static WADO has no efficient per-frame endpoint, so for multiframe
+        // SEG, fetch the whole instance once and serve frames from the registry.
+        // Value is the max ms to wait for that fetch before proceeding (0 = off).
+        loadMultiframeAsPart10RaceTimeMs: 3000,
         bulkDataURI: {
           enabled: true,
           relativeResolution: 'studies',
diff --git a/platform/app/public/customizations/segmentation/binary.jsonc b/platform/app/public/customizations/segmentation/binary.jsonc
new file mode 100644
index 00000000000..3cc902f4166
--- /dev/null
+++ b/platform/app/public/customizations/segmentation/binary.jsonc
@@ -0,0 +1,19 @@
+// URL-loaded customization: segmentation/binary
+//
+// Stores exported/saved DICOM SEG objects as a BINARY Segmentation — SOP Class
+// 1.2.840.10008.5.1.4.1.1.66.4 (one frame per segment) — instead of the OHIF
+// default Label Map Segmentation 1.2.840.10008.5.1.4.1.1.66.7. Binary SEG is
+// broadly compatible with existing PACS/viewers; Label Map was only added to
+// DICOM in 2024 and many back ends reject it.
+//
+// Applied in the `global` phase so it overrides the default registered by the
+// cornerstone-dicom-seg extension. A data source may still override this per
+// back end via `configuration.segmentation.store.defaultMode`.
+//
+// Load it with `?customization=segmentation/binary` (combine with
+// `&customization=segmentation/uncompressed` to also drop RLE compression).
+{
+  "global": {
+    "segmentation.store.defaultMode": { "$set": "bitmap" }
+  }
+}
diff --git a/platform/app/public/customizations/segmentation/uncompressed.jsonc b/platform/app/public/customizations/segmentation/uncompressed.jsonc
new file mode 100644
index 00000000000..200ba86f437
--- /dev/null
+++ b/platform/app/public/customizations/segmentation/uncompressed.jsonc
@@ -0,0 +1,19 @@
+// URL-loaded customization: segmentation/uncompressed
+//
+// Stores exported/saved DICOM SEG objects UNCOMPRESSED — Explicit VR Little
+// Endian (1.2.840.10008.1.2.1) — instead of the OHIF default of RLE Lossless
+// (1.2.840.10008.1.2.5). Use this for back ends that reject compressed SEG
+// PixelData.
+//
+// Applied in the `global` phase. With this key left unset OHIF passes no
+// transfer syntax and the adapter falls back to RLE Lossless; setting it here
+// forces uncompressed instead. A data source may still override this per back
+// end via `configuration.segmentation.store.transferSyntaxUID`.
+//
+// Load it with `?customization=segmentation/uncompressed` (combine with
+// `&customization=segmentation/binary` to also switch the SOP class).
+{
+  "global": {
+    "segmentation.store.transferSyntaxUID": { "$set": "1.2.840.10008.1.2.1" }
+  }
+}
diff --git a/platform/core/package.json b/platform/core/package.json
index e99c8063636..2927896740a 100644
--- a/platform/core/package.json
+++ b/platform/core/package.json
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@babel/runtime": "7.29.7",
-    "dcmjs": "0.49.4",
+    "dcmjs": "0.52.0",
     "dicomweb-client": "0.10.4",
     "gl-matrix": "3.4.3",
     "immutability-helper": "3.1.1",
diff --git a/platform/core/src/classes/MetadataProvider.ts b/platform/core/src/classes/MetadataProvider.ts
index 1b8d4308534..57f9abff3d2 100644
--- a/platform/core/src/classes/MetadataProvider.ts
+++ b/platform/core/src/classes/MetadataProvider.ts
@@ -1,7 +1,7 @@
 import queryString from 'query-string';
 import dicomParser from 'dicom-parser';
 import { utilities } from '@cornerstonejs/core';
-import { imageIdToURI } from '../utils';
+import { baseImageURIForMetadata } from '../utils/imageIdToURI';
 import DicomMetadataStore from '../services/DicomMetadataStore';
 import fetchPaletteColorLookupTableData from '../utils/metadataProvider/fetchPaletteColorLookupTableData';
 import toNumber from '../utils/toNumber';
@@ -24,12 +24,12 @@ class MetadataProvider {
     // This method is a fallback for when you don't have WADO-URI or WADO-RS.
     // You can add instances fetched by any method by calling addInstance, and hook an imageId to point at it here.
     // An example would be dicom hosted at some random site.
-    const imageURI = imageIdToURI(imageId);
+    const imageURI = baseImageURIForMetadata(imageId);
     this.imageURIToUIDs.set(imageURI, uids);
   }
 
   addCustomMetadata(imageId, type, metadata) {
-    const imageURI = imageIdToURI(imageId);
+    const imageURI = baseImageURIForMetadata(imageId);
     if (!this.customMetadata.has(type)) {
       this.customMetadata.set(type, {});
     }
@@ -76,7 +76,7 @@ class MetadataProvider {
     // check inside custom metadata
     if (this.customMetadata.has(query)) {
       const customMetadata = this.customMetadata.get(query);
-      const imageURI = imageIdToURI(imageId);
+      const imageURI = baseImageURIForMetadata(imageId);
       if (customMetadata[imageURI]) {
         return customMetadata[imageURI];
       }
@@ -445,6 +445,9 @@ class MetadataProvider {
     if (imageId.includes('/frames')) {
       return getInformationFromURL('/frames', '/');
     }
+    if (imageId.includes('?frame=')) {
+      return getInformationFromURL('?frame=', '&');
+    }
     if (imageId.includes('&frame=')) {
       return getInformationFromURL('&frame=', '&');
     }
@@ -473,20 +476,7 @@ class MetadataProvider {
       };
     }
 
-    // Maybe its a non-standard imageId
-    // check if the imageId starts with http:// or https:// using regex
-    // Todo: handle non http imageIds
-    let imageURI;
-    const urlRegex = /^(http|https|dicomfile):\/\//;
-    if (urlRegex.test(imageId)) {
-      imageURI = imageId;
-    } else {
-      imageURI = imageIdToURI(imageId);
-    }
-
-    // remove &frame=number from imageId
-    imageURI = imageURI.split('&frame=')[0];
-
+    const imageURI = baseImageURIForMetadata(imageId);
     const uids = this.imageURIToUIDs.get(imageURI);
     const frameNumber = this.getFrameInformationFromURL(imageId) || '1';
 
diff --git a/platform/core/src/utils/combineFrameInstance.ts b/platform/core/src/utils/combineFrameInstance.ts
index 657619d0053..0067300f464 100644
--- a/platform/core/src/utils/combineFrameInstance.ts
+++ b/platform/core/src/utils/combineFrameInstance.ts
@@ -83,6 +83,9 @@ const combineFrameInstance = (frame, instance) => {
     if (!instance._parentInstance) {
       Object.defineProperty(instance, '_parentInstance', {
         value: { ...instance },
+        enumerable: false,
+        writable: false,
+        configurable: false,
       });
     }
     const sharedInstance = createCombinedValue(
@@ -102,7 +105,7 @@ const combineFrameInstance = (frame, instance) => {
     Object.defineProperty(newInstance, 'frameNumber', {
       value: frameNumber,
       writable: true,
-      enumerable: true,
+      enumerable: false,
       configurable: true,
     });
     return newInstance;
@@ -113,6 +116,9 @@ const combineFrameInstance = (frame, instance) => {
     if (!instance._parentInstance) {
       Object.defineProperty(instance, '_parentInstance', {
         value: { ...instance },
+        enumerable: false,
+        writable: false,
+        configurable: false,
       });
     }
 
@@ -144,7 +150,7 @@ const combineFrameInstance = (frame, instance) => {
     Object.defineProperty(newInstance, 'frameNumber', {
       value: frameNumber,
       writable: true,
-      enumerable: true,
+      enumerable: false,
       configurable: true,
     });
 
diff --git a/platform/core/src/utils/imageIdToURI.js b/platform/core/src/utils/imageIdToURI.js
index 7be55b07588..dd094c93cb2 100644
--- a/platform/core/src/utils/imageIdToURI.js
+++ b/platform/core/src/utils/imageIdToURI.js
@@ -10,3 +10,20 @@ export default function imageIdToURI(imageId) {
 
   return imageId.substring(colonIndex + 1);
 }
+
+/**
+ * Normalizes an imageId to the metadata lookup key (scheme stripped, frame query removed).
+ * Must match MetadataProvider.getUIDsFromImageID lookup behavior.
+ */
+export function baseImageURIForMetadata(imageId) {
+  const urlRegex = /^(http|https|dicomfile):\/\//;
+  let imageURI;
+
+  if (urlRegex.test(imageId)) {
+    imageURI = imageId;
+  } else {
+    imageURI = imageIdToURI(imageId);
+  }
+
+  return imageURI.split('&frame=')[0].split('?frame=')[0];
+}
diff --git a/platform/docs/docs/behaviours/README.md b/platform/docs/docs/behaviours/README.md
new file mode 100644
index 00000000000..b4c6975b43a
--- /dev/null
+++ b/platform/docs/docs/behaviours/README.md
@@ -0,0 +1,42 @@
+---
+id: README
+title: Behaviours
+sidebar_position: 0
+---
+
+# Behaviours
+
+This section documents **how the system and UI actually behave** — the
+end-to-end behaviours that emerge from the interaction of services, extensions,
+the data source, and Cornerstone3D, rather than the API of any single module.
+
+It is the place for:
+
+- **Observed behaviours** — how a feature works today across the stack (e.g. how
+  a DICOM SEG is fetched, decoded, and rendered; what the viewport does on study
+  change; how measurements round-trip to SR).
+- **Design proposals** — proposed or in-progress changes to a behaviour, captured
+  before/while they are implemented so the intent and trade-offs are recorded.
+  These are clearly marked as proposals until they land.
+- **Edge cases and failure modes** — what happens when something is missing,
+  slow, or malformed, and how the system is expected to degrade.
+
+The goal is a durable, discoverable record of *behaviour* — the kind of
+cross-cutting knowledge that is otherwise only in people's heads or scattered
+across code comments. Prefer linking to the relevant source files (with line
+references) so each behaviour doc stays anchored to the code it describes.
+
+## Index
+
+- [Segmentation: loading a multiframe SEG as a single Part 10 instance](./segmentation-multiframe-part10-prefetch.md)
+  — _implemented, opt-in_. Prefetch the whole instance in one request and register
+  it into the Cornerstone3D NATURALIZED frame registry so the per-frame load path
+  (WADO-RS and WADO-URI) is served locally, while keeping the standard decode path
+  unchanged. Enable via `cornerstone.segmentation.loadMultiframeAsPart10RaceTimeMs`.
+
+## Writing a new behaviour doc
+
+1. Add a `kebab-case.md` file in this directory.
+2. State whether it documents **current behaviour** or is a **proposal**.
+3. Link to the code (`path:line`) that implements or will implement it.
+4. Add it to the **Index** above.
diff --git a/platform/docs/docs/behaviours/_category_.json b/platform/docs/docs/behaviours/_category_.json
new file mode 100644
index 00000000000..7dec1b789cc
--- /dev/null
+++ b/platform/docs/docs/behaviours/_category_.json
@@ -0,0 +1,8 @@
+{
+  "label": "Behaviours",
+  "position": 14,
+  "link": {
+    "type": "doc",
+    "id": "behaviours/README"
+  }
+}
diff --git a/platform/docs/docs/behaviours/segmentation-multiframe-part10-prefetch.md b/platform/docs/docs/behaviours/segmentation-multiframe-part10-prefetch.md
new file mode 100644
index 00000000000..506f42d6e1e
--- /dev/null
+++ b/platform/docs/docs/behaviours/segmentation-multiframe-part10-prefetch.md
@@ -0,0 +1,364 @@
+# Full-instance prefetch for segmentation (and multiframe) loading
+
+Status: **Implemented — opt-in (disabled by default)**
+
+Enable per data source by setting `loadMultiframeAsPart10RaceTimeMs` to a positive
+number of milliseconds in the data source `configuration` (this is how the static
+WADO backends in `config/default.js` and `config/e2e.js` turn it on, value
+`3000`). It also falls back to the global customization
+`cornerstone.segmentation.loadMultiframeAsPart10RaceTimeMs`. `0`/unset keeps
+today's per-frame behaviour. The value is the **max ms to wait** for the
+single-instance fetch+parse before proceeding (the load proceeds immediately once
+it completes; on timeout it falls back to per-frame and the registration still
+benefits later frames).
+
+Implemented across:
+
+- `@cornerstonejs/dicom-image-loader`
+  - `imageLoader/prefetchPart10Instance.ts` — registers a Part 10 instance into
+    the frame registry (thin wrapper over `addDicomPart10Instance`).
+  - `imageLoader/wadors/loadImageFromRegistry.ts` +
+    `wadors/loadImage.ts` — WADO-RS loads now consult the registry first.
+- `@ohif/extension-default` `DicomWebDataSource` — `retrieve.prefetchInstanceFrames`.
+- `@ohif/extension-cornerstone-dicom-seg` `getSopClassHandlerModule.ts` — call
+  site + race.
+
+Related: `@cornerstonejs/adapters` `labelmapImagesFromBuffer.ts`
+(`decodeSegPixelDataFromFrameIds`, bounded by `concurrency`, default 16).
+
+## Problem
+
+The SEG load path now fetches/decodes frames through the cornerstone image
+loader, one loadable `imageId` per frame, parallelized up to `N=16`
+(`concurrency`). For a SEG (or any multiframe instance) with **800+ small
+frames**, this means 800+ independent HTTP requests, each with its own
+request/response overhead. Even at 16-wide concurrency the *per-request* latency
+floor dominates: each frame is < 1 KB of payload but pays a full round trip.
+
+Streaming **one large object** (the entire Part 10 / multiframe instance) is far
+cheaper than streaming hundreds of tiny ones — a single connection, a single set
+of headers, no per-frame TTFB. The whole instance for an 800-frame binary SEG is
+typically a few hundred KB to a few MB.
+
+## Goal
+
+Add a **generic data-source capability** that, _just before_ the segmentation
+loader runs, optionally fetches the **entire original instance** in one request
+and **registers it into the Cornerstone3D frame registry** (the
+`@cornerstonejs/metadata` NATURALIZED + `COMPRESSED_FRAME_DATA` framework, parsed
+by the dcmjs async reader) — so the existing per-frame `imageId` fetch path
+transparently hits local data instead of the network, while the **cornerstone
+decode path stays byte-for-byte identical** (same decompressor, same workers).
+
+Crucially this is **best-effort and non-blocking**:
+
+- It is gated by a **race time in ms**, `loadMultiframeAsPart10RaceTimeMs`. We
+  kick off the full-instance fetch and give it up to that long of a head start,
+  then proceed on the **normal per-frame path** regardless. Frames already
+  registered are served locally; frames not yet registered fall through to their
+  normal network fetch.
+- If `loadMultiframeAsPart10RaceTimeMs` is `0` / `undefined`, the capability is
+  **disabled** — no full-instance fetch is attempted.
+- If the full-instance fetch or parse **fails for any reason**, it must **never**
+  fail the segmentation decode. We log and fall back to per-frame fetches.
+
+## Why this is safe / transparent
+
+There is **one uniform frame registry: the Cornerstone3D `@cornerstonejs/metadata`
+NATURALIZED framework**, populated by `addDicomPart10Instance` (which parses the
+Part 10 with the dcmjs `AsyncDicomReader`) and read per-frame via the
+`COMPRESSED_FRAME_DATA` typed provider. Frame imageIds are normalized to the base
+instance by `baseImageIdQueryFilter` (strips `/frames/N`, `?frame=N`, `&frame=N`),
+so one registration under the instance serves every frame.
+
+This is the **same registry the WADO-URI / `dicomweb` loader already uses**:
+`wadouri/loadImage.ts`'s `loadImageFromNaturalizedMetadata` resolves each frame
+from `COMPRESSED_FRAME_DATA` and decodes it with `createImage`. The gap was that
+**WADO-RS** (`wadors/loadImage.ts`) always issued a per-frame `/frames/N` request
+and never consulted the registry. The adapter closes that gap:
+
+- `wadors/loadImageFromRegistry.ts` — `loadImageFromCompressedFrameRegistry(imageId)`
+  looks up `COMPRESSED_FRAME_DATA` for the frame; if present it decodes via the
+  **same `createImage`** path and returns the image; if absent it returns
+  `undefined`.
+- `wadors/loadImage.ts` calls it first and short-circuits when the registry has
+  the frame, otherwise falls through to the existing network path.
+
+So once `prefetchPart10Instance` has registered the instance, **both WADO-URI and
+WADO-RS** serve every frame from the single registry, with the **same decode
+pipeline** (`createImage` → worker decoder). From cornerstone's perspective
+nothing changed except the compressed bytes came from the registry instead of the
+wire.
+
+> Rejected alternatives: (1) a bespoke `Map<imageId, frame>` registry plus
+> `getPixelData` shims — duplicates a registry that already exists; (2) seeding
+> the core image cache (`cache.putImageLoadObject`) per frame — works, but the
+> per-frame compressed data already lives in the NATURALIZED registry, so basing
+> the design on that registry (and teaching WADO-RS to read it) keeps a single
+> source of truth instead of copying frames into a second cache.
+
+## API (as implemented)
+
+A generic capability on the data source's `retrieve` namespace (so it works for
+any multiframe instance, not just SEG, and alternate data sources can override
+it), plus the SEG handler call site that races it.
+
+`IWebApiDataSource.create` passes `retrieve` through verbatim, so the capability
+is added there (no `@ohif/core` change):
+
+```ts
+// On the data source (DicomWebDataSource):
+dataSource.retrieve.prefetchInstanceFrames({
+  instance,                          // study/series/sop UIDs for retrieveInstance
+  imageId,                           // SEG instance imageId (frame qualifiers normalized away)
+  loadMultiframeAsPart10RaceTimeMs,  // 0/undefined => no-op
+}): {
+  done: Promise<boolean>;            // resolves true if fetched+registered, false if skipped/failed
+  cancel: () => void;
+};
+```
+
+The implementation fetches the instance with `wadoDicomWebClient.retrieveInstance`
+(which returns the Part 10 as an `ArrayBuffer`, unwrapping `multipart/related`
+transparently) and passes a **lazy resolver** to
+`dicomImageLoader.prefetchPart10Instance(imageId, resolver)`. All work is wrapped
+so any failure resolves `done` to `false` — it never throws into the loader.
+
+### Call site (just before the loader)
+
+In `getSopClassHandlerModule.ts`, immediately before
+`createFromDicomSegImageId(...)` (abridged from the actual code):
+
+```ts
+const loadMultiframeAsPart10RaceTimeMs =
+  (dataSource?.getConfig?.()?.loadMultiframeAsPart10RaceTimeMs as number | undefined) ??
+  (customizationService?.getCustomization?.(
+    'cornerstone.segmentation.loadMultiframeAsPart10RaceTimeMs'
+  ) as number | undefined) ??
+  0;
+
+let prefetch;
+if (loadMultiframeAsPart10RaceTimeMs > 0) {
+  prefetch = dataSource.retrieve?.prefetchInstanceFrames?.({
+    instance,
+    imageId: segImageIdForMetadata,
+    loadMultiframeAsPart10RaceTimeMs,
+  });
+  if (prefetch?.done) {
+    // Give the bulk fetch a head start, then proceed regardless.
+    const raceTimer = new Promise(r => setTimeout(r, loadMultiframeAsPart10RaceTimeMs));
+    await Promise.race([prefetch.done, raceTimer]);
+  }
+}
+
+try {
+  results = await adaptersSEG.Cornerstone3D.Segmentation.createFromDicomSegImageId(
+    imageIds,
+    segImageIdForMetadata,
+    { metadataProvider: metaData, tolerance, parserType, frameImageIds,
+      concurrency: SEG_FRAME_DECODE_CONCURRENCY }
+  );
+} finally {
+  eventTarget.removeEventListener(Enums.Events.SEGMENTATION_LOAD_PROGRESS, onProgress);
+  prefetch?.cancel?.();
+}
+```
+
+The SEG loader and adapter are **unchanged** — the loader still asks the image
+loader for each frame. Registered frames resolve from the registry; the rest
+fetch normally.
+
+## Mechanism (the 4 requested points)
+
+### 1. Async DICOM reader (dcmjs) to parse the instance
+
+Parsing is done by `@cornerstonejs/metadata`'s `addDicomPart10Instance`, which
+uses the dcmjs **`AsyncDicomReader`** (`naturalizePart10Buffer` in
+`naturalizedHandlers.ts`) and understands encapsulated PixelData fragmentation,
+so the NATURALIZED instance exposes pixel data as an array of per-frame
+ArrayBuffer fragments. `COMPRESSED_FRAME_DATA` then slices out the requested
+frame. We did not re-implement any parsing — the prefetch just feeds the fetched
+Part 10 buffer to this existing reader.
+
+**Implemented as full-buffer v1**: the whole instance is fetched, then parsed.
+`addDicomPart10Instance` accepts a lazy resolver, so the fetch is what the race
+waits on. Progressive/streaming registration (registering frames as bytes arrive)
+is a future optimization — see rollout step 4.
+
+#### Response envelope: `multipart/related` vs raw DICOM
+
+The full-instance fetch can come back in **two shapes**, and the parser must
+handle both before any DICOM parsing happens:
+
+- **`multipart/related`** — a WADO-RS instance retrieve
+  (`GET …/instances/{sop}` with `Accept: multipart/related; type="application/dicom"`)
+  wraps the Part 10 object(s) in a MIME multipart envelope: leading part headers,
+  a `--boundary` marker, the DICOM bytes, then a terminal `--boundary--`. The
+  inner DICOM byte offsets are **shifted** by the MIME header length, so dcmjs
+  must be fed the *unwrapped* inner part, never the raw response.
+- **raw DICOM** — WADO-URI, a direct file/object URL, or a `bulkDataURI` that
+  returns a single `application/dicom` body: the response **is** the Part 10
+  bytes, no envelope.
+
+**As implemented**, the full-buffer path delegates this to **`dicomweb-client`'s
+`retrieveInstance`**, which performs the WADO-RS instance retrieve and returns the
+Part 10 as an `ArrayBuffer` with the `multipart/related` envelope already
+unwrapped (and returns the single-part body as-is). `prefetchInstanceFrames`
+additionally tolerates an `[ArrayBuffer]` or `ArrayBufferView` shape defensively.
+So the implemented path is:
+
+```
+retrieveInstance() → ArrayBuffer (multipart unwrapped by dicomweb-client)
+                   → prefetchPart10Instance → addDicomPart10Instance → dcmjs AsyncDicomReader
+```
+
+Detection by `Content-Type` and manual unwrapping (the approach `wadors/extractMultipart.ts`
+uses: `contentType.indexOf('multipart') === -1` → bytes as-is; else strip the
+boundary/part headers) becomes relevant only for the **future streaming path**
+(rollout step 4), where these wrinkles must be handled directly:
+
+- The multipart preamble/boundary stripped at the **start** of the stream and the
+  terminal boundary detected at the **end**; a boundary token can **straddle chunk
+  boundaries**, so the unwrapper must buffer across chunks (the existing
+  `findIndexOfString` + `tokenIndex` carry-over in `extractMultipart` is built for
+  incremental calls).
+- `multipart/related` may contain **multiple parts**; a single-instance retrieve
+  yields one — guard for >1.
+- A truncated/partial body (no terminal boundary yet) must not be mis-parsed.
+
+### 2. Register the compressed data into the frame registry
+
+The fetched Part 10 buffer is registered **once per instance** via the
+`prefetchPart10Instance` adapter (a thin wrapper over `addDicomPart10Instance`):
+
+```ts
+// @cornerstonejs/dicom-image-loader: imageLoader/prefetchPart10Instance.ts
+import { utilities } from '@cornerstonejs/metadata';
+const { addDicomPart10Instance } = utilities;
+
+export function prefetchPart10Instance(baseImageId, part10 /* buffer | resolver */) {
+  return addDicomPart10Instance(baseImageId, part10);
+}
+```
+
+That populates NATURALIZED for the instance; `COMPRESSED_FRAME_DATA` then yields
+each frame's compressed bytes + transfer syntax on demand. Frame imageIds
+normalize to the instance key automatically (`baseImageIdQueryFilter`), so there
+is no per-frame registration loop and no second cache to keep coherent — the
+registry **is** the existing NATURALIZED framework.
+
+The "few new adapters" the task calls for:
+
+1. `prefetchPart10Instance(baseImageId, part10)` — entry point to register a
+   fetched instance into the registry (exported from
+   `@cornerstonejs/dicom-image-loader`).
+2. `loadImageFromCompressedFrameRegistry(imageId, options)` in
+   `wadors/loadImageFromRegistry.ts` — teaches the **WADO-RS** loader to read the
+   registry. It looks up `COMPRESSED_FRAME_DATA` for the frame and, if present,
+   decodes via the same `createImage` the network path uses; `wadors/loadImage.ts`
+   calls it first and short-circuits on a hit. (WADO-URI already reads the
+   registry via `loadImageFromNaturalizedMetadata`.)
+
+Metadata the decoder needs (`imagePixelModule`, transfer syntax) comes from the
+same NATURALIZED instance, plus the SEG handler's existing
+`_ensureSegInstanceMetadataAvailable` per frame imageId.
+
+### 3. Cornerstone uses its existing decompressor — identical downstream
+
+Both the WADO-URI path and the new WADO-RS registry path decode via
+`createImage` (→ the same web-worker decoder used for every network frame), so
+encapsulated transfer syntaxes are decompressed exactly as if fetched per-frame
+and native/uncompressed frames pass through unchanged. No new decode path, no
+codec changes, no divergence in pixel output — the only difference is that the
+compressed bytes came from the registry instead of the wire.
+
+### 4. Failure is non-fatal — fall back to per-frame fetches
+
+`prefetchInstanceFrames` wraps the fetch + parse so that **any** failure (network
+error, cancel, parse error, unexpected `retrieveInstance` shape) resolves
+`done` to `false` and logs a warning — it never throws into the SEG load. When
+the registry has no data for a frame, `loadImageFromCompressedFrameRegistry`
+returns `undefined` and the WADO-RS loader falls through to its normal
+`/frames/N` request. So if the prefetch is slow, disabled, or fails, loading is
+exactly today's per-frame behaviour.
+
+Edge cases that degrade gracefully:
+
+- Race timer expires before the parse completes → frames load over the network
+  meanwhile; once registration completes, remaining frames hit the registry.
+- `cancel()` (viewport closed / segmentation removed mid-load) → the resolver
+  throws on its cancelled flag; `done` resolves `false`; any already-registered
+  data stays usable.
+- A misbehaving metadata provider → the registry lookup is wrapped in try/catch
+  and returns `undefined`, so per-frame loading is never broken.
+
+## Race semantics (the `loadMultiframeAsPart10RaceTimeMs` knob)
+
+- `loadMultiframeAsPart10RaceTimeMs == 0 || undefined` → **disabled**. Today's
+  default. No behavior change until we opt in.
+- `loadMultiframeAsPart10RaceTimeMs > 0` → start the full-instance fetch+parse,
+  then `Promise.race([prefetch.done, delay(loadMultiframeAsPart10RaceTimeMs)])`
+  before handing control to the loader. This gives the bulk transfer a head start
+  so frames are already in the registry, while guaranteeing we never stall the
+  load longer than the race time if the server is slow. If the timer wins, the
+  loader proceeds and frames fetch per-frame meanwhile; once registration
+  completes, the remaining frames are served from the registry.
+
+> `addDicomPart10Instance` registers the instance atomically (one parse), so in
+> practice registration is all-or-nothing rather than progressive — the race time
+> is "how long to wait for the whole fetch+parse before proceeding." Progressive
+> registration (rollout step 4) would make the head start matter per-frame.
+
+A sensible starting value once enabled is something like 250–750 ms (enough to
+beat per-frame TTFB on most servers), tuned per deployment.
+
+## Where the generic capability lives
+
+- The **registry is the existing `@cornerstonejs/metadata` NATURALIZED framework**
+  — no new cache. New code in `@cornerstonejs/dicom-image-loader` is the thin
+  adapter `prefetchPart10Instance()` plus the WADO-RS read path
+  (`wadors/loadImageFromRegistry.ts`, wired into `wadors/loadImage.ts`).
+- The **fetch + register orchestration** lives in the **data source**
+  (`extensions/default/.../DicomWebDataSource` → `retrieve.prefetchInstanceFrames`),
+  because it knows how to retrieve a full instance (auth headers, `wadoRoot`,
+  WADO-RS instance retrieve via `dicomweb-client`, CORS), and so alternate data
+  sources can implement/override it.
+- The SEG handler only **reads the customization and orchestrates the race**.
+
+This keeps the layering clean: data source = "how to get bytes", image loader =
+"how to register/decode bytes", SEG handler = "when to ask".
+
+## Open questions / risks
+
+1. **NATURALIZED registry key alignment.** Both registration
+   (`addDicomPart10Instance`) and the WADO-RS read normalize frame imageIds to the
+   base instance via `baseImageIdQueryFilter`, so they agree. Worth a sanity check
+   per data source that the SEG `imageId` passed to `prefetchInstanceFrames` and
+   the frame imageIds the SEG loader requests share the same instance base.
+2. **Memory.** Holding the full instance plus the still-compressed frames in the
+   registry raises memory for that instance until it is evicted. Compressed frames
+   are small and decode is on-demand. Registry/cache eviction lifecycle for
+   prefetched instances should be verified (especially repeated SEG loads).
+3. **Streaming availability.** v1 uses a single full-buffer `retrieveInstance`. A
+   future streaming path (step 4) would register frames as bytes arrive.
+4. **Auth / headers.** Handled — the resolver sets
+   `wadoDicomWebClient.headers = getAuthorizationHeader()` before retrieve, reusing
+   the data source's existing decoration.
+5. **Per-frame overhead.** Every WADO-RS load now does one cheap
+   `COMPRESSED_FRAME_DATA` lookup (a Map get after base normalization) before
+   falling through. Negligible, and only short-circuits when an instance was
+   actually prefetched.
+
+## Incremental rollout
+
+1. ✅ `prefetchPart10Instance` adapter + WADO-RS registry read
+   (`wadors/loadImageFromRegistry.ts`) in dicom-image-loader. No behaviour change
+   until something registers an instance.
+2. ✅ `retrieve.prefetchInstanceFrames` in DicomWebDataSource (full-buffer v1 via
+   `retrieveInstance`) behind `loadMultiframeAsPart10RaceTimeMs` default `0`.
+3. ✅ SEG handler call site + race. **Next:** enable with a small
+   `loadMultiframeAsPart10RaceTimeMs` in a test deployment and measure 800-frame
+   SEG load time before defaulting it on.
+4. ⏳ Progressive (streaming) parse to register frames as they arrive (handle the
+   `multipart/related` unwrap + boundary-straddle directly).
+5. ⏳ Extend to other multiframe loaders (the registry path is generic).
diff --git a/platform/docs/docs/platform/services/customization-service/specificCustomizations.md b/platform/docs/docs/platform/services/customization-service/specificCustomizations.md
index 6680b54e0ae..49e626d9c71 100644
--- a/platform/docs/docs/platform/services/customization-service/specificCustomizations.md
+++ b/platform/docs/docs/platform/services/customization-service/specificCustomizations.md
@@ -232,3 +232,120 @@ integration must trigger loading explicitly (for example by calling
 `customizationService.applyCustomizationUrlSearchParams` or `customizationService.requires` with
 the new list). New module keys not seen before can still be loaded that way; unloading or
 replacing an already-loaded pack is not supported out of the box.
+
+## `segmentation.store.*` (DICOM SEG export encoding)
+
+These customizations control how the `@ohif/extension-cornerstone-dicom-seg` extension
+encodes a DICOM SEG when it is **stored or downloaded**, and are read when a SEG is
+generated.
+
+| Key | Values | Default | Controls |
+| --- | --- | --- | --- |
+| `segmentation.store.defaultMode` | `'labelmap'` \| `'bitmap'` | `'labelmap'` | SEG SOP Class |
+| `segmentation.store.transferSyntaxUID` | a transfer-syntax UID string | unset → RLE Lossless | PixelData encoding |
+
+- **`segmentation.store.defaultMode`**
+  - `'labelmap'` → Label Map Segmentation Storage (`1.2.840.10008.5.1.4.1.1.66.7`). One
+    multi-valued frame per slice. Added to DICOM in 2024, so many PACS/viewers do not
+    accept it yet.
+  - `'bitmap'` → (binary) Segmentation Storage (`1.2.840.10008.5.1.4.1.1.66.4`). One frame
+    per segment; broadly compatible with existing back ends and viewers.
+- **`segmentation.store.transferSyntaxUID`**
+  - Unset (the default) → the adapter encodes as RLE Lossless (`1.2.840.10008.1.2.5`,
+    compressed).
+  - `1.2.840.10008.1.2.1` → Explicit VR Little Endian (**uncompressed**). Use this for back
+    ends that reject compressed SEG PixelData.
+
+> OHIF's effective default is **Label Map + RLE Lossless (compressed)**: `defaultMode` is
+> `'labelmap'` and, with `transferSyntaxUID` left unset, the adapter falls back to RLE
+> Lossless.
+
+### URL-loaded files (recommended)
+
+Two ready-made public customization files ship under
+`platform/app/public/customizations/segmentation/`, so a user can flip either default
+straight from the URL (requires `customizationUrlPrefixes.default` to be configured — it
+is in the `dev` / `netlify` configs):
+
+| File | `?customization=` value | Effect |
+| --- | --- | --- |
+| `segmentation/uncompressed.jsonc` | `segmentation/uncompressed` | Explicit VR Little Endian instead of RLE |
+| `segmentation/binary.jsonc` | `segmentation/binary` | Binary SEG (66.4) instead of Label Map (66.7) |
+
+They are independent and combine, so you can apply both at once:
+
+```
+http://host/viewer?customization=segmentation/uncompressed&customization=segmentation/binary
+```
+
+Each file just `$set`s one key in the `global` phase, e.g. `segmentation/binary.jsonc`:
+
+```jsonc
+{
+  "global": {
+    "segmentation.store.defaultMode": { "$set": "bitmap" }
+  }
+}
+```
+
+The remaining forms below set the same keys directly in `window.config` instead of via the
+URL.
+
+### Store an uncompressed SEG instead of the compressed default
+
+```js
+window.config = {
+  customizationService: [
+    {
+      'segmentation.store.transferSyntaxUID': {
+        $set: '1.2.840.10008.1.2.1', // Explicit VR Little Endian (uncompressed)
+      },
+    },
+  ],
+};
+```
+
+### Store a binary SEG (66.4) instead of the default Label Map (66.7)
+
+```js
+window.config = {
+  customizationService: [
+    {
+      'segmentation.store.defaultMode': { $set: 'bitmap' },
+    },
+  ],
+};
+```
+
+### Per data source override
+
+A data source may override the app-wide default for one back end only, under
+`configuration.segmentation.store`. **The data source value wins over the customization
+default**, so different back ends can pick the SEG encoding they support:
+
+```js
+window.config = {
+  // App-wide default (optional): Label Map + RLE unless set here.
+  customizationService: [
+    { 'segmentation.store.defaultMode': { $set: 'labelmap' } },
+  ],
+  dataSources: [
+    {
+      namespace: '@ohif/extension-default.dataSourcesModule.dicomweb',
+      sourceName: 'myPacs',
+      configuration: {
+        // ...wado/qido/stow roots...
+        segmentation: {
+          store: {
+            defaultMode: 'bitmap', // this PACS only accepts binary SEG
+            transferSyntaxUID: '1.2.840.10008.1.2.1', // and only uncompressed
+          },
+        },
+      },
+    },
+  ],
+};
+```
+
+When storing, the override is resolved against the data source being written to; for
+download (no target data source) the active data source's override applies.
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 8e6e1e5b710..06edeaaca29 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -8,7 +8,7 @@ overrides:
   commander: 8.3.0
   cross-env: 7.0.3
   cross-spawn: 7.0.6
-  dcmjs: 0.49.4
+  dcmjs: 0.52.0
   path-to-regexp: 0.1.13
   nth-check: 2.1.1
   trim-newlines: 5.0.0
@@ -244,8 +244,8 @@ importers:
         specifier: workspace:*
         version: link:../../platform/ui
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       dicom-parser:
         specifier: 1.8.21
         version: 1.8.21
@@ -458,8 +458,8 @@ importers:
         specifier: 2.5.1
         version: 2.5.1
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       dicom-parser:
         specifier: 1.8.21
         version: 1.8.21
@@ -507,8 +507,8 @@ importers:
         specifier: 2.5.1
         version: 2.5.1
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       dicom-parser:
         specifier: 1.8.21
         version: 1.8.21
@@ -541,8 +541,8 @@ importers:
         specifier: workspace:*
         version: link:../../platform/i18n
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       dicomweb-client:
         specifier: 0.10.4
         version: 0.10.4
@@ -571,6 +571,9 @@ importers:
         specifier: 1.8.11
         version: 1.8.11(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
     devDependencies:
+      cross-env:
+        specifier: 7.0.3
+        version: 7.0.3
       webpack-merge:
         specifier: 5.10.0
         version: 5.10.0
@@ -651,8 +654,8 @@ importers:
         specifier: 2.5.1
         version: 2.5.1
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       dicom-parser:
         specifier: 1.8.21
         version: 1.8.21
@@ -685,8 +688,8 @@ importers:
         specifier: 2.5.1
         version: 2.5.1
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       dicom-parser:
         specifier: 1.8.21
         version: 1.8.21
@@ -734,8 +737,8 @@ importers:
         specifier: 2.5.1
         version: 2.5.1
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       lodash.debounce:
         specifier: 4.0.8
         version: 4.0.8
@@ -752,6 +755,9 @@ importers:
         specifier: 4.38.3
         version: 4.38.3
     devDependencies:
+      cross-env:
+        specifier: 7.0.3
+        version: 7.0.3
       webpack-merge:
         specifier: 5.10.0
         version: 5.10.0
@@ -771,8 +777,8 @@ importers:
         specifier: 2.5.1
         version: 2.5.1
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       dicom-parser:
         specifier: 1.8.21
         version: 1.8.21
@@ -805,8 +811,8 @@ importers:
         specifier: 2.5.1
         version: 2.5.1
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       dicom-parser:
         specifier: 1.8.21
         version: 1.8.21
@@ -954,6 +960,9 @@ importers:
         specifier: workspace:*
         version: link:../../extensions/dicom-video
     devDependencies:
+      cross-env:
+        specifier: 7.0.3
+        version: 7.0.3
       webpack-merge:
         specifier: 5.10.0
         version: 5.10.0
@@ -985,6 +994,9 @@ importers:
         specifier: 17.3.1
         version: 17.3.1
     devDependencies:
+      cross-env:
+        specifier: 7.0.3
+        version: 7.0.3
       webpack-merge:
         specifier: 5.10.0
         version: 5.10.0
@@ -1022,6 +1034,9 @@ importers:
         specifier: 17.3.1
         version: 17.3.1
     devDependencies:
+      cross-env:
+        specifier: 7.0.3
+        version: 7.0.3
       webpack-merge:
         specifier: 5.10.0
         version: 5.10.0
@@ -1065,6 +1080,9 @@ importers:
         specifier: 17.3.1
         version: 17.3.1
     devDependencies:
+      cross-env:
+        specifier: 7.0.3
+        version: 7.0.3
       webpack-merge:
         specifier: 5.10.0
         version: 5.10.0
@@ -1240,6 +1258,9 @@ importers:
         specifier: 17.3.1
         version: 17.3.1
     devDependencies:
+      cross-env:
+        specifier: 7.0.3
+        version: 7.0.3
       webpack-merge:
         specifier: 5.10.0
         version: 5.10.0
@@ -1371,8 +1392,8 @@ importers:
         specifier: 0.1.10
         version: 0.1.10
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       detect-gpu:
         specifier: 4.0.50
         version: 4.0.50
@@ -1564,8 +1585,8 @@ importers:
         specifier: 0.1.10
         version: 0.1.10
       dcmjs:
-        specifier: 0.49.4
-        version: 0.49.4
+        specifier: 0.52.0
+        version: 0.52.0
       dicom-parser:
         specifier: 1.8.21
         version: 1.8.21
@@ -3325,8 +3346,8 @@ packages:
     resolution: {integrity: sha512-JfoPiD7f/vvd/PaOfu5cr9CyzwDMPg4T0nX3MQr6IgTq49DhjvUcmjmjA7j6+xih1Evq+QKZnge1SoIlYozv/Q==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/runtime-corejs3@7.29.0':
-    resolution: {integrity: sha512-TgUkdp71C9pIbBcHudc+gXZnihEDOjUAmXO1VO4HHGES7QLZcShR0stfKIxLSNIYx2fqhmJChOjm/wkF8wv4gA==}
+  '@babel/runtime-corejs3@7.29.2':
+    resolution: {integrity: sha512-Lc94FOD5+0aXhdb0Tdg3RUtqT6yWbI/BbFWvlaSJ3gAb9Ks+99nHRDKADVqC37er4eCB0fHyWT+y+K3QOvJKbw==}
     engines: {node: '>=6.9.0'}
 
   '@babel/runtime@7.29.2':
@@ -6336,8 +6357,8 @@ packages:
     resolution: {integrity: sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==}
     engines: {node: '>= 10.0.0'}
 
-  adm-zip@0.5.16:
-    resolution: {integrity: sha512-TGw5yVi4saajsSEgz25grObGHEUaDrniwvA2qwSC060KfqGPdglhvPMA2lPIoxs3PQIItj2iag35fONcQqgUaQ==}
+  adm-zip@0.5.17:
+    resolution: {integrity: sha512-+Ut8d9LLqwEvHHJl1+PIHqoyDxFgVN847JTVM3Izi3xHDWPE4UtzzXysMZQs64DMcrJfBeS/uoEP4AD3HQHnQQ==}
     engines: {node: '>=12.0'}
 
   agent-base@6.0.2:
@@ -7590,8 +7611,9 @@ packages:
   dayjs@1.11.20:
     resolution: {integrity: sha512-YbwwqR/uYpeoP4pu043q+LTDLFBLApUP6VxRihdfNTqu4ubqMlGDLd6ErXhEgsyvY0K6nCs7nggYumAN+9uEuQ==}
 
-  dcmjs@0.49.4:
-    resolution: {integrity: sha512-w77Gde5JvLjg37FyGIAsTB+oWZIqkO/5NvBeheEVKy6k9XjBgeGsoAbVAByjuGAFLpGqRbf9iWI0edBq87yu/g==}
+  dcmjs@0.52.0:
+    resolution: {integrity: sha512-0/mT9NACKnwnOnkUx7JAqmWxRcUr7HiCoptw1KhN2StNYE0Hy6+tmpI7CU+lJuBc4rFpcMCalvI8QO6JkJ+7Fg==}
+    engines: {node: '>=22.13'}
 
   debounce@1.2.1:
     resolution: {integrity: sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==}
@@ -8508,6 +8530,9 @@ packages:
   gl-matrix@3.4.3:
     resolution: {integrity: sha512-wcCp8vu8FT22BnvKVPjXa/ICBWRq/zjFfdofZy1WSpQZpphblv12/bOQLBC1rMM7SGOFS9ltVmKOHil5+Ml7gA==}
 
+  gl-matrix@3.4.4:
+    resolution: {integrity: sha512-latSnyDNt/8zYUB6VIJ6PCh2jBjJX6gnDsoCZ7LyW7GkqrD51EWwa9qCoGixj8YqBtETQK/xY7OmpTF8xz1DdQ==}
+
   glob-parent@6.0.2:
     resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
     engines: {node: '>=10.13.0'}
@@ -16201,7 +16226,7 @@ snapshots:
       core-js: 3.45.1
       regenerator-runtime: 0.14.1
 
-  '@babel/runtime-corejs3@7.29.0':
+  '@babel/runtime-corejs3@7.29.2':
     dependencies:
       core-js-pure: 3.49.0
 
@@ -16266,7 +16291,7 @@ snapshots:
       '@cornerstonejs/core': 5.1.3(@babel/preset-env@7.29.7(@babel/core@7.29.7))(@cornerstonejs/metadata@5.1.3)(@cornerstonejs/utils@5.1.3)(autoprefixer@10.4.27(postcss@8.5.14))(wslink@2.5.0)
       '@cornerstonejs/tools': 5.1.3(@cornerstonejs/core@5.1.3(@babel/preset-env@7.29.7(@babel/core@7.29.7))(@cornerstonejs/metadata@5.1.3)(@cornerstonejs/utils@5.1.3)(autoprefixer@10.4.27(postcss@8.5.14))(wslink@2.5.0))(@kitware/vtk.js@35.5.3(@babel/preset-env@7.29.7(@babel/core@7.29.7))(autoprefixer@10.4.27(postcss@8.5.14))(wslink@2.5.0))(@types/d3-array@3.2.1)(@types/d3-interpolate@3.0.4)(d3-array@3.2.4)(d3-interpolate@3.0.1)(gl-matrix@3.4.3)
       buffer: 6.0.3
-      dcmjs: 0.49.4
+      dcmjs: 0.52.0
       gl-matrix: 3.4.3
       ndarray: 1.0.19
 
@@ -16276,7 +16301,7 @@ snapshots:
       '@cornerstonejs/core': 5.1.3(@babel/preset-env@7.29.7(@babel/core@7.29.7))(@cornerstonejs/metadata@5.1.3)(@cornerstonejs/utils@5.1.3)(autoprefixer@10.4.27(postcss@8.5.14))(wslink@2.5.0)
       '@cornerstonejs/tools': 5.1.3(@cornerstonejs/core@5.1.3(@babel/preset-env@7.29.7(@babel/core@7.29.7))(@cornerstonejs/metadata@5.1.3)(@cornerstonejs/utils@5.1.3)(autoprefixer@10.4.27(postcss@8.5.14))(wslink@2.5.0))(@kitware/vtk.js@35.5.3(@babel/preset-env@7.29.7(@babel/core@7.29.7))(autoprefixer@10.4.27(postcss@8.5.14))(wslink@2.5.0))(@types/d3-array@3.2.1)(@types/d3-interpolate@3.0.4)(d3-array@3.2.4)(d3-interpolate@3.0.1)(gl-matrix@3.4.3)
       buffer: 6.0.3
-      dcmjs: 0.49.4
+      dcmjs: 0.52.0
       gl-matrix: 3.4.3
       lodash.clonedeep: 4.5.0
       ndarray: 1.0.19
@@ -16337,7 +16362,7 @@ snapshots:
     dependencies:
       '@cornerstonejs/calculate-suv': 1.0.3
       '@cornerstonejs/utils': 5.1.3
-      dcmjs: 0.49.4
+      dcmjs: 0.52.0
       gl-matrix: 3.4.3
 
   '@cornerstonejs/polymorphic-segmentation@5.1.3(@cornerstonejs/core@5.1.3(@babel/preset-env@7.29.7(@babel/core@7.29.7))(@cornerstonejs/metadata@5.1.3)(@cornerstonejs/utils@5.1.3)(autoprefixer@10.4.27(postcss@8.5.14))(wslink@2.5.0))(@cornerstonejs/tools@5.1.3(@cornerstonejs/core@5.1.3(@babel/preset-env@7.29.7(@babel/core@7.29.7))(@cornerstonejs/metadata@5.1.3)(@cornerstonejs/utils@5.1.3)(autoprefixer@10.4.27(postcss@8.5.14))(wslink@2.5.0))(@kitware/vtk.js@35.5.3(@babel/preset-env@7.29.7(@babel/core@7.29.7))(autoprefixer@10.4.27(postcss@8.5.14))(wslink@2.5.0))(@types/d3-array@3.2.1)(@types/d3-interpolate@3.0.4)(d3-array@3.2.4)(d3-interpolate@3.0.1)(gl-matrix@3.4.3))(@kitware/vtk.js@35.5.3(@babel/preset-env@7.29.7(@babel/core@7.29.7))(autoprefixer@10.4.27(postcss@8.5.14))(wslink@2.5.0))':
@@ -16362,7 +16387,7 @@ snapshots:
 
   '@cornerstonejs/utils@5.1.3':
     dependencies:
-      dcmjs: 0.49.4
+      dcmjs: 0.52.0
 
   '@cspotcode/source-map-support@0.8.1':
     dependencies:
@@ -20293,7 +20318,7 @@ snapshots:
 
   address@1.2.2: {}
 
-  adm-zip@0.5.16: {}
+  adm-zip@0.5.17: {}
 
   agent-base@6.0.2:
     dependencies:
@@ -21830,11 +21855,11 @@ snapshots:
 
   dayjs@1.11.20: {}
 
-  dcmjs@0.49.4:
+  dcmjs@0.52.0:
     dependencies:
-      '@babel/runtime-corejs3': 7.29.0
-      adm-zip: 0.5.16
-      gl-matrix: 3.4.3
+      '@babel/runtime-corejs3': 7.29.2
+      adm-zip: 0.5.17
+      gl-matrix: 3.4.4
       lodash.clonedeep: 4.5.0
       loglevel: 1.9.2
       ndarray: 1.0.19
@@ -22029,7 +22054,7 @@ snapshots:
       '@cornerstonejs/codec-openjpeg': 1.3.0
       '@cornerstonejs/codec-openjph': 2.4.7
       colormap: 2.3.2
-      dcmjs: 0.49.4
+      dcmjs: 0.52.0
       dicomicc: 0.1.0
       dicomweb-client: 0.10.4
       image-type: 4.1.0
@@ -22255,7 +22280,7 @@ snapshots:
       has-property-descriptors: 1.0.2
       has-proto: 1.2.0
       has-symbols: 1.1.0
-      hasown: 2.0.3
+      hasown: 2.0.4
       internal-slot: 1.1.0
       is-array-buffer: 3.0.5
       is-callable: 1.2.7
@@ -22319,7 +22344,7 @@ snapshots:
 
   es-shim-unscopables@1.1.0:
     dependencies:
-      hasown: 2.0.3
+      hasown: 2.0.4
 
   es-to-primitive@1.3.0:
     dependencies:
@@ -22882,6 +22907,8 @@ snapshots:
 
   gl-matrix@3.4.3: {}
 
+  gl-matrix@3.4.4: {}
+
   glob-parent@6.0.2:
     dependencies:
       is-glob: 4.0.3
@@ -23560,7 +23587,7 @@ snapshots:
 
   is-core-module@2.16.2:
     dependencies:
-      hasown: 2.0.3
+      hasown: 2.0.4
 
   is-data-view@1.0.2:
     dependencies:
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 5c4f4c91021..9db464fa470 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -42,7 +42,7 @@ overrides:
   commander: 8.3.0
   cross-env: 7.0.3
   cross-spawn: 7.0.6
-  dcmjs: 0.49.4
+  dcmjs: 0.52.0
   path-to-regexp: 0.1.13
   nth-check: 2.1.1
   trim-newlines: 5.0.0
diff --git a/rsbuild.config.ts b/rsbuild.config.ts
index d99ac45e2b0..f324e32014a 100644
--- a/rsbuild.config.ts
+++ b/rsbuild.config.ts
@@ -75,6 +75,16 @@ export default defineConfig({
       },
       module: {
         rules: [
+          // Consume the source maps emitted by the linked local Cornerstone
+          // packages (libs/@cornerstonejs, via cs3d:link + cs3d:watch) so browser
+          // stack traces and breakpoints resolve to the original .ts instead of
+          // the bundled dist/esm .js. Scoped to the linked packages only.
+          {
+            test: /\.js$/,
+            enforce: 'pre',
+            use: [require.resolve('source-map-loader')],
+            include: /libs[\\/]@cornerstonejs[\\/]packages[\\/][^\\/]+[\\/]dist[\\/]esm/,
+          },
           {
             test: /\.css$/,
             use: [