fix: use fresh workers for labelmap read/write to avoid WASM heap overflow

Replace resetWorker() (which terminated the shared ITK-wasm worker while
in-flight operations still referenced it) with per-labelmap temporary
workers. Each labelmap read/write gets its own fresh worker with a clean
WASM heap, avoiding the 2GB signed pointer overflow in Emscripten without
disrupting any concurrent operations on the shared worker.

Author: PaulHax

src/io/import/processors/restoreStateFile.ts

@@ -20,7 +20,6 @@ import { useViewStore } from '@/src/store/views';
 import { useViewConfigStore } from '@/src/store/view-configs';
 import { migrateManifest } from '@/src/io/state-file/migrations';
 import { useMessageStore } from '@/src/store/messages';
-import { resetWorker } from '@/src/io/itk/worker';
 
 type LeafSource =
   | { type: 'uri'; uri: string; name: string; mime?: string }
@@ -137,12 +136,6 @@ export async function completeStateFileRestore(
 
   useViewConfigStore().deserializeAll(manifest, stateIDToStoreID);
 
-  // Reset the ITK-wasm worker to free accumulated WASM heap from loading
-  // base images. Without this, loading large labelmaps on the same worker
-  // can push the heap past 2GB, causing signed pointer overflow in
-  // Emscripten's ccall (pointers > 2^31 wrap negative).
-  await resetWorker();
-
   const segmentGroupIDMap = await useSegmentGroupStore().deserialize(
     manifest,
     stateFiles,

src/io/itk/worker.ts

@@ -33,14 +33,6 @@ export function getWorker() {
   return webWorker;
 }
 
-export async function resetWorker() {
-  if (webWorker) {
-    webWorker.terminate();
-    webWorker = null;
-  }
-  await ensureWorker();
-}
-
 export function getDicomSeriesWorkerPool() {
   return readDicomSeriesWorkerPool;
 }

src/io/readWriteImage.ts

@@ -8,23 +8,29 @@ import {
 import { vtiReader, vtiWriter } from '@/src/io/vtk/async';
 import { getWorker } from '@/src/io/itk/worker';
 
-export const readImage = async (file: File) => {
+export const readImage = async (file: File, webWorker?: Worker | null) => {
   if (file.name.endsWith('.vti'))
     return (await vtiReader(file)) as vtkImageData;
 
-  const { image } = await readImageItk(file, { webWorker: getWorker() });
+  const { image } = await readImageItk(file, {
+    webWorker: webWorker ?? getWorker(),
+  });
   return vtkITKHelper.convertItkToVtkImage(image);
 };
 
-export const writeImage = async (format: string, image: vtkImageData) => {
+export const writeImage = async (
+  format: string,
+  image: vtkImageData,
+  webWorker?: Worker | null
+) => {
   if (format === 'vti') {
     return vtiWriter(image);
   }
   // copyImage so writeImage does not detach live data when passing to worker
   const itkImage = copyImage(vtkITKHelper.convertVtkToItkImage(image));
 
   const result = await writeImageItk(itkImage, `image.${format}`, {
-    webWorker: getWorker(),
+    webWorker: webWorker ?? getWorker(),
   });
   return result.serializedImage.data as Uint8Array<ArrayBuffer>;
 };

src/io/state-file/serialize.ts

@@ -60,7 +60,9 @@ export async function serialize() {
   await datasetStore.serialize(stateFile);
   viewStore.serialize(stateFile);
   await useViewConfigStore().serialize(stateFile);
+
   await labelStore.serialize(stateFile);
+
   toolStore.serialize(stateFile);
   await layersStore.serialize(stateFile);
 

src/store/segmentGroups.ts

@@ -10,6 +10,7 @@ import { onImageDeleted } from '@/src/composables/onImageDeleted';
 import { normalizeForStore, removeFromArray } from '@/src/utils';
 import { SegmentMask } from '@/src/types/segment';
 import { DEFAULT_SEGMENT_MASKS, CATEGORICAL_COLORS } from '@/src/config';
+import { createWebWorker } from 'itk-wasm';
 import { readImage, writeImage } from '@/src/io/readWriteImage';
 import {
   type DataSelection,
@@ -480,12 +481,21 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
 
     state.manifest.segmentGroups = serialized;
 
-    // save labelmap images
+    // save labelmap images — fresh worker per write to avoid heap accumulation
     await Promise.all(
       serialized.map(async ({ id, path }) => {
         const vtkImage = dataIndex[id];
-        const serializedImage = await writeImage(saveFormat.value, vtkImage);
-        zip.file(path, serializedImage);
+        const worker = await createWebWorker(null);
+        try {
+          const serializedImage = await writeImage(
+            saveFormat.value,
+            vtkImage,
+            worker
+          );
+          zip.file(path, serializedImage);
+        } finally {
+          worker.terminate();
+        }
       })
     );
   }
@@ -527,7 +537,14 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
       const file = stateFiles.find(
         (entry) => entry.archivePath === normalize(segmentGroup.path!)
       )?.file;
-      return { image: await readImage(file!) };
+      // Use a fresh worker per labelmap to avoid WASM heap accumulation.
+      // The shared worker may already have a large heap from base images.
+      const worker = await createWebWorker(null);
+      try {
+        return { image: await readImage(file!, worker) };
+      } finally {
+        worker.terminate();
+      }
     }
 
     const labelmapResults = await Promise.all(