fix(mega): delete sidecars with the volume; stop sc-poll crash; fix delete toast

Three issues found deleting a MEGA-backed volume:
- Sidecars (.mokuro, thumbnail .webp) were orphaned: deleteFile removes only
  one node. Add unifiedCloudManager.deleteManagedVolume() which deletes the
  archive + all managed sidecars (sidecars first, .cbz last so a sidecar
  failure leaves the volume retryable). VolumeItem's two delete paths use it.
- Toast 'Cannot read properties of undefined (reading provider)': onBackupClicked
  read the reactive cloudFile after the await re-derived it to undefined.
  Capture the provider before the await.
- megajs 'Cannot read properties of undefined (reading parent)' crash: the
  keepalive server-change (sc) poll has a buggy delete handler. We never use
  push updates (we reload explicitly), so create sessions with keepalive:false
  (login + both fromJSON restore sites).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Gnathonic

src/lib/components/VolumeItem.svelte

@@ -345,10 +345,10 @@
           deleteVolumeStats(volume.volume_uuid);
         }
 
-        // Delete from cloud if checkbox checked
+        // Delete from cloud if checkbox checked (archive + sidecars)
         if (deleteCloud && hasCloudBackup && cloudFile) {
           try {
-            await unifiedCloudManager.deleteFile(cloudFile);
+            await unifiedCloudManager.deleteManagedVolume(volume.series_title, volume.volume_title);
             showSnackbar(`Deleted from ${providerDisplayName}`);
           } catch (error) {
             console.error('Failed to delete from cloud:', error);
@@ -468,9 +468,12 @@
 
     // If already backed up, delete from cloud
     if (isBackedUp && cloudFile) {
+      // Capture provider before the await: cloudFile is a $derived that becomes
+      // undefined once the delete refreshes the cache.
+      const providerType = cloudFile.provider;
       try {
-        await unifiedCloudManager.deleteFile(cloudFile);
-        const providerName = cloudFile.provider === 'google-drive' ? 'Drive' : cloudFile.provider;
+        await unifiedCloudManager.deleteManagedVolume(volume.series_title, volume.volume_title);
+        const providerName = providerType === 'google-drive' ? 'Drive' : providerType;
         showSnackbar(`Deleted from ${providerName}`);
       } catch (error) {
         console.error('Delete failed:', error);

src/lib/util/sync/core/providers/mega-core.ts

@@ -36,7 +36,12 @@ async function getUploadStorage(session: string): Promise<Storage> {
 
   uploadSessionKey = sessionKey;
   const pendingSession = (async () => {
-    const storage = Storage.fromJSON(parsed) as any;
+    // keepalive:false: no server-change poll in the worker session (we don't need it,
+    // and its handler crashes on delete events).
+    const storage = Storage.fromJSON({
+      ...parsed,
+      options: { ...(parsed.options ?? {}), keepalive: false }
+    }) as any;
     // fromJSON loads no tree; reload populates storage.root for folder navigation/upload.
     await storage.reload(true);
     return storage as Storage;

src/lib/util/sync/providers/mega/mega-provider.test.ts

@@ -93,6 +93,15 @@ describe('MegaProvider.login()', () => {
     expect(storageState.lastOptions.secondFactorCode).toBe('654321');
   });
 
+  it('logs in with keepalive disabled (no crashing server-change poll)', async () => {
+    const provider = new MegaProvider();
+    await provider.whenReady();
+
+    await provider.login({ email: 'a@b.c', password: 'secret' });
+
+    expect(storageState.lastOptions.keepalive).toBe(false);
+  });
+
   it('maps EMFAREQUIRED to a MFA_REQUIRED ProviderError', async () => {
     storageState.loginError = new Error('EMFAREQUIRED (-26): Multi-Factor Authentication Required');
     const provider = new MegaProvider();

src/lib/util/sync/providers/mega/mega-provider.ts

@@ -260,9 +260,12 @@ export class MegaProvider implements SyncProvider {
 
       // Fresh interactive login. The constructor cb fires after the tree loads
       // (autoload:true), so the Storage is ready once this promise resolves.
+      // keepalive:false disables megajs's server-change (sc) long-poll. We never use
+      // push notifications (we reload explicitly), and that poll's handler crashes on
+      // delete events ("Cannot read properties of undefined (reading 'parent')").
       const storage: any = await new Promise((resolve, reject) => {
         const s = new Storage(
-          { email, password, secondFactorCode, autoload: true } as any,
+          { email, password, secondFactorCode, autoload: true, keepalive: false } as any,
           (error: Error | null) => (error ? reject(error) : resolve(s))
         );
       });
@@ -325,7 +328,12 @@ export class MegaProvider implements SyncProvider {
   /** Rebuild an authenticated Storage from a saved session blob (no password, no login round-trip). */
   private async restoreSession(blob: MegaSessionBlob): Promise<void> {
     const { Storage } = await import('megajs');
-    const storage: any = Storage.fromJSON(blob as any);
+    // Force keepalive:false so the restored session never starts the crashing sc poll,
+    // even for blobs persisted before that default changed.
+    const storage: any = Storage.fromJSON({
+      ...(blob as any),
+      options: { ...((blob as any).options ?? {}), keepalive: false }
+    });
     // fromJSON does no network and loads no tree; reload populates root + files.
     // A dead session throws ESID here.
     await storage.reload(true);

src/lib/util/sync/unified-cloud-manager.test.ts

@@ -173,3 +173,63 @@ describe('UnifiedCloudManager rename operations', () => {
     );
   });
 });
+
+describe('UnifiedCloudManager.deleteManagedVolume', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const baseFiles = (): CloudFileMetadata[] => [
+    { provider: 'mega', fileId: 'cbz-1', path: 'S/Vol 1.cbz', modifiedTime: '', size: 100 },
+    { provider: 'mega', fileId: 'mokuro-1', path: 'S/Vol 1.mokuro', modifiedTime: '', size: 10 },
+    { provider: 'mega', fileId: 'thumb-1', path: 'S/Vol 1.webp', modifiedTime: '', size: 5 },
+    { provider: 'mega', fileId: 'other-1', path: 'S/Vol 2.cbz', modifiedTime: '', size: 100 }
+  ];
+
+  it('deletes the archive and all sidecars (archive last) and clears the cache', async () => {
+    const cache = { removeById: vi.fn() };
+    const deleted: string[] = [];
+    const provider = {
+      type: 'mega',
+      deleteFile: vi.fn(async (file: CloudFileMetadata) => {
+        deleted.push(file.path);
+      })
+    };
+    const files = baseFiles();
+    getActiveProvider.mockReturnValue(provider);
+    getBySeries.mockImplementation((s: string) => files.filter((f) => f.path.startsWith(`${s}/`)));
+    getCache.mockReturnValue(cache);
+
+    const { unifiedCloudManager } = await import('$lib/util/sync/unified-cloud-manager');
+    await unifiedCloudManager.deleteManagedVolume('S', 'Vol 1');
+
+    // Only Vol 1's three files (not Vol 2), and the .cbz archive is deleted LAST.
+    expect(provider.deleteFile).toHaveBeenCalledTimes(3);
+    expect(deleted).not.toContain('S/Vol 2.cbz');
+    expect(deleted[deleted.length - 1]).toBe('S/Vol 1.cbz');
+    expect(cache.removeById).toHaveBeenCalledTimes(3);
+  });
+
+  it('reports a summary on partial failure but still clears the successes', async () => {
+    const cache = { removeById: vi.fn() };
+    const provider = {
+      type: 'mega',
+      deleteFile: vi.fn(async (file: CloudFileMetadata) => {
+        if (file.path.endsWith('.mokuro')) throw new Error('boom');
+      })
+    };
+    const files = baseFiles();
+    getActiveProvider.mockReturnValue(provider);
+    getBySeries.mockImplementation((s: string) => files.filter((f) => f.path.startsWith(`${s}/`)));
+    getCache.mockReturnValue(cache);
+
+    const { unifiedCloudManager } = await import('$lib/util/sync/unified-cloud-manager');
+    await expect(unifiedCloudManager.deleteManagedVolume('S', 'Vol 1')).rejects.toThrow(
+      /Failed to delete 1 of 3/
+    );
+    // The .cbz and .webp still got removed from cache; only the .mokuro failed.
+    expect(cache.removeById).toHaveBeenCalledWith('cbz-1');
+    expect(cache.removeById).toHaveBeenCalledWith('thumb-1');
+    expect(cache.removeById).not.toHaveBeenCalledWith('mokuro-1');
+  });
+});

src/lib/util/sync/unified-cloud-manager.ts

@@ -197,6 +197,46 @@ class UnifiedCloudManager {
     }
   }
 
+  /**
+   * Delete a backed-up volume and ALL its managed cloud files (archive + sidecars).
+   * deleteFile() removes only a single node, which leaves the .mokuro and thumbnail
+   * sidecars orphaned. Sidecars are deleted first and the .cbz archive last, so a
+   * sidecar failure leaves the volume still marked backed-up (and retryable) rather
+   * than half-deleted.
+   */
+  async deleteManagedVolume(seriesTitle: string, volumeTitle: string): Promise<void> {
+    const provider = this.getActiveProvider();
+    if (!provider) {
+      throw new Error('No cloud provider authenticated');
+    }
+
+    const files = this.getManagedCloudFilesForVolume(seriesTitle, volumeTitle);
+    if (files.length === 0) return;
+
+    const ordered = [...files].sort(
+      (a, b) =>
+        Number(normalizeCloudPath(a.path).endsWith('.cbz')) -
+        Number(normalizeCloudPath(b.path).endsWith('.cbz'))
+    );
+
+    const cache = cacheManager.getCache(provider.type);
+    const failures: string[] = [];
+    for (const file of ordered) {
+      try {
+        await provider.deleteFile(file);
+        cache?.removeById?.(file.fileId);
+      } catch (error) {
+        failures.push(`${file.path}: ${error instanceof Error ? error.message : 'error'}`);
+      }
+    }
+
+    if (failures.length > 0) {
+      throw new Error(
+        `Failed to delete ${failures.length} of ${files.length} file(s): ${failures.join('; ')}`
+      );
+    }
+  }
+
   private replaceCachedFile(oldFile: CloudFileMetadata, updatedFile: CloudFileMetadata): void {
     const provider = this.getActiveProvider();
     if (!provider) return;