test(e2e): reproduce WASM RangeError for large session restore

Rewrite session-large-uri-base test to actually trigger the signed
pointer overflow bug. Uses a ZIP-based session with a Float32
1024×1024×256 base image (1GB raw, pushes WASM heap past 2GB) and
an embedded .nii.gz labelmap referenced via `path` in segmentGroups.

Key changes:
- ZIP session format with `path`-based labelmap triggers readImage()
  on the shared ITK-wasm worker (the old dataSourceId approach used
  cached data and never hit the bug path)
- Float32 base image grows the WASM heap past 2GB so output pointers
  exceed 2^31 and wrap negative via Emscripten's signed i32 ccall
- .nii.gz labelmap format is critical: .vti uses a separate JS reader
  that never touches the ITK-wasm worker
- Wait for async labelmap deserialization via notification/segment-group
  detection (it completes after views render)

Verified: fails with RangeError when resetWorker() is removed,
passes when the fix is active.

Author: PaulHax

tests/specs/session-large-uri-base.e2e.ts

@@ -1,9 +1,9 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as zlib from 'node:zlib';
+import JSZip from 'jszip';
 import { cleanuptotal } from 'wdio-cleanuptotal-service';
 import { volViewPage } from '../pageobjects/volview.page';
-import { writeManifestToFile } from './utils';
 import { DOWNLOAD_TIMEOUT, TEMP_DIR } from '../../wdio.shared.conf';
 
 const writeBufferToFile = async (data: Buffer, fileName: string) => {
@@ -60,69 +60,86 @@ const createNiftiGz = (
   return zlib.gzipSync(Buffer.concat([header, imageData]), { level: 1 });
 };
 
+const createSessionZip = async (
+  baseFileName: string,
+  labelmapNiftiGz: Buffer
+) => {
+  const manifest = {
+    version: '6.2.0',
+    dataSources: [
+      {
+        id: 0,
+        type: 'uri',
+        uri: `/tmp/${baseFileName}`,
+        name: baseFileName,
+      },
+    ],
+    datasets: [{ id: '0', dataSourceId: 0 }],
+    segmentGroups: [
+      {
+        id: 'seg-1',
+        path: 'labels/seg-1.nii.gz',
+        metadata: {
+          name: 'Annotation',
+          parentImage: '0',
+          segments: {
+            order: [1],
+            byValue: {
+              '1': {
+                value: 1,
+                name: 'Label 1',
+                color: [255, 0, 0, 255],
+                visible: true,
+              },
+            },
+          },
+        },
+      },
+    ],
+  };
+
+  const zip = new JSZip();
+  zip.file('manifest.json', JSON.stringify(manifest, null, 2));
+  zip.file('labels/seg-1.nii.gz', labelmapNiftiGz);
+  return zip.generateAsync({ type: 'nodebuffer', compression: 'STORE' });
+};
+
 /**
- * Regression test for session restore with large base image + labelmap.
+ * Regression test for WASM signed pointer overflow during session restore.
+ *
+ * A .volview.zip session with a large Float32 URI-based base image and an
+ * embedded .nii.gz labelmap. The import pipeline loads the base image
+ * through the shared ITK-wasm worker, growing the WASM heap past 2GB.
+ * Then segmentGroupStore.deserialize() calls readImage() for the embedded
+ * .nii.gz labelmap on the same worker.
+ *
+ * The .nii.gz format is critical: .vti labelmaps use a separate JS
+ * reader and never touch the ITK-wasm worker.
  *
- * Scenario: Int16 1024×1024×172 base image loaded via URI, with a UInt8
- * labelmap of the same dimensions. On the shared ITK-wasm worker, base
- * image processing grew the WASM heap to ~1721MB. Loading the labelmap
- * on the same worker pushed it past 2GB, causing signed pointer overflow
- * in Emscripten's ccall (output pointers > 2^31 wrap negative →
- * RangeError: Start offset -N is outside the bounds).
+ * Without resetting the worker, Emscripten's ccall returns output pointers
+ * as signed i32. When pointers exceed 2^31 they wrap negative, causing:
+ *   RangeError: Start offset -N is outside the bounds of the buffer
  *
- * Fix: reset the ITK-wasm worker before deserializing labelmaps to
- * prevent heap accumulation.
+ * Fix: resetWorker() before deserializing labelmaps clears the heap.
  */
-describe('Session with large URI base and labelmap', function () {
+describe('Session with large URI base and nii.gz labelmap', function () {
   this.timeout(180_000);
 
-  it('loads large base image with labelmap without errors', async () => {
+  it('loads session with large Float32 base and embedded nii.gz labelmap', async () => {
     const prefix = `session-large-${Date.now()}`;
-    const baseFileName = `${prefix}-base-i16.nii.gz`;
-    const labelmapFileName = `${prefix}-labelmap-u8.nii.gz`;
+    const baseFileName = `${prefix}-base-f32.nii.gz`;
+    const sessionFileName = `${prefix}-session.volview.zip`;
 
-    // Int16 1024×1024×172 = 361MB raw
+    // Float32 1024×1024×256 = 1GB raw — pushes WASM heap past 2GB
     await writeBufferToFile(
-      createNiftiGz(1024, 1024, 172, 4, 16),
+      createNiftiGz(1024, 1024, 256, 16, 32),
       baseFileName
     );
-    // UInt8 labelmap same dimensions = 180MB raw
-    await writeBufferToFile(
-      createNiftiGz(1024, 1024, 172, 2, 8),
-      labelmapFileName
-    );
-
-    const manifest = {
-      version: '6.1.0',
-      dataSources: [
-        { id: 0, type: 'uri', uri: `/tmp/${baseFileName}` },
-        { id: 1, type: 'uri', uri: `/tmp/${labelmapFileName}` },
-      ],
-      labelMaps: [
-        {
-          id: 'seg-1',
-          dataSourceId: 1,
-          metadata: {
-            name: 'Annotation',
-            parentImage: '0',
-            segments: {
-              order: [1],
-              byValue: {
-                '1': {
-                  value: 1,
-                  name: 'Label 1',
-                  color: [255, 0, 0, 255],
-                  visible: true,
-                },
-              },
-            },
-          },
-        },
-      ],
-    };
 
-    const manifestFileName = `${prefix}-manifest.volview.json`;
-    await writeManifestToFile(manifest, manifestFileName);
+    // UInt8 labelmap same dimensions = 256MB raw, embedded in session ZIP
+    const labelmapNiftiGz = createNiftiGz(1024, 1024, 256, 2, 8);
+    const sessionZip = await createSessionZip(baseFileName, labelmapNiftiGz);
+    await writeBufferToFile(sessionZip, sessionFileName);
 
     const rangeErrors: string[] = [];
     const onLogEntry = (logEntry: { text: string | null }) => {
@@ -134,15 +151,10 @@ describe('Session with large URI base and labelmap', function () {
     browser.on('log.entryAdded', onLogEntry);
 
     try {
-      await volViewPage.open(`?urls=[tmp/${manifestFileName}]`);
+      await volViewPage.open(`?urls=[tmp/${sessionFileName}]`);
       await volViewPage.waitForViews(DOWNLOAD_TIMEOUT * 6);
 
-      expect(rangeErrors).toEqual([]);
-
-      const notifications = await volViewPage.getNotificationsCount();
-      expect(notifications).toEqual(0);
-
-      // Verify segment group loaded
+      // Open the segment groups panel so the list renders in the DOM
       const annotationsTab = await $(
         'button[data-testid="module-tab-Annotations"]'
       );
@@ -152,16 +164,30 @@ describe('Session with large URI base and labelmap', function () {
       await segmentGroupsTab.waitForClickable();
       await segmentGroupsTab.click();
 
+      // Wait for the labelmap readImage to either succeed (segment group
+      // appears) or fail (RangeError in console OR error notification).
+      // The deserialization is async and finishes after views render.
+      const notifsBefore = await volViewPage.getNotificationsCount();
+
       await browser.waitUntil(
         async () => {
+          if (rangeErrors.length > 0) return true;
+          try {
+            const notifs = await volViewPage.getNotificationsCount();
+            if (notifs > notifsBefore) return true;
+          } catch {
+            // badge may not exist yet
+          }
           const segmentGroups = await $$('.segment-group-list .v-list-item');
           return (await segmentGroups.length) >= 1;
         },
         {
-          timeout: DOWNLOAD_TIMEOUT,
-          timeoutMsg: 'Segment group not found after session restore',
+          timeout: DOWNLOAD_TIMEOUT * 3,
+          timeoutMsg: 'Labelmap load never completed or errored',
         }
       );
+
+      expect(rangeErrors).toEqual([]);
     } finally {
       browser.off('log.entryAdded', onLogEntry);
     }