diff --git a/apps/ferret/package.json b/apps/ferret/package.json
index b24f983d..33c7a5e8 100644
--- a/apps/ferret/package.json
+++ b/apps/ferret/package.json
@@ -19,12 +19,17 @@
   "dependencies": {
     "@craig/db": "workspace:*",
     "@craig/logger": "workspace:*",
+    "@henrygd/queue": "^1.0.7",
+    "@libav.js/variant-webcodecs": "^6.8.8",
+    "@wasm-audio-decoders/flac": "^0.2.8",
     "destr": "^2.0.5",
     "emittery": "^1.2.0",
     "eventemitter3": "^5.0.1",
     "ioredis": "^5.9.2",
     "just-clone": "^6.2.0",
+    "mediabunny": "^1.21.1",
     "nanoid": "^5.1.6",
+    "opus-decoder": "^0.7.10",
     "zod": "^4.3.5"
   },
   "devDependencies": {
@@ -44,12 +49,14 @@
     "@sveltejs/enhanced-img": "^0.8.5",
     "@sveltejs/kit": "^2.49.5",
     "@sveltejs/vite-plugin-svelte": "^6.2.4",
+    "@types/wicg-file-system-access": "^2023.10.6",
     "autoprefixer": "^10.4.23",
     "clsx": "^2.1.1",
     "cookie-es": "^2.0.0",
     "discord-api-types": "^0.38.37",
     "fflate": "^0.8.2",
     "just-range": "^4.2.0",
+    "mime": "^4.1.0",
     "postcss": "^8.5.6",
     "postcss-load-config": "^6.0.1",
     "sass": "^1.97.2",
diff --git a/apps/ferret/src/components/Checkbox.svelte b/apps/ferret/src/components/Checkbox.svelte
index 70f16ccc..69dfb03f 100644
--- a/apps/ferret/src/components/Checkbox.svelte
+++ b/apps/ferret/src/components/Checkbox.svelte
@@ -1,14 +1,16 @@
 <script lang="ts">
-  interface Props {
+  import type { HTMLInputAttributes } from 'svelte/elements';
+
+  interface Props extends Omit<HTMLInputAttributes, 'type' | 'class'> {
     id?: string | undefined;
     checked: boolean;
     disabled?: boolean;
   }
 
-  let { id = undefined, checked = $bindable(), disabled = false }: Props = $props();
+  let { id = undefined, checked = $bindable(), disabled = false, ...rest }: Props = $props();
 </script>
 
-<input {id} type="checkbox" class="h-6 w-6 flex-none cursor-pointer" bind:checked {disabled} />
+<input {id} type="checkbox" class="h-6 w-6 flex-none cursor-pointer" bind:checked {disabled} {...rest} />
 
 <style lang="scss">
   input[type='checkbox'] {
diff --git a/apps/ferret/src/components/FormatButton.svelte b/apps/ferret/src/components/FormatButton.svelte
index 7c893459..c171e1c3 100644
--- a/apps/ferret/src/components/FormatButton.svelte
+++ b/apps/ferret/src/components/FormatButton.svelte
@@ -3,6 +3,7 @@
 
   interface Props {
     ennuizel?: boolean;
+    minizel?: boolean;
     disabled?: boolean;
     icon?: IconifyIcon | null;
     suffix?: string;
@@ -10,10 +11,10 @@
     children?: import('svelte').Snippet;
   }
 
-  let { ennuizel = false, disabled = false, icon = null, suffix = '', onclick, children }: Props = $props();
+  let { ennuizel = false, minizel = false, disabled = false, icon = null, suffix = '', onclick, children }: Props = $props();
 </script>
 
-<button class:ennuizel {disabled} {onclick}>
+<button class:ennuizel class:minizel {disabled} {onclick}>
   {#if icon}
     <Icon {icon} class="scale-125" />
   {/if}
@@ -48,6 +49,10 @@
       @apply border-red-500 bg-red-500 bg-opacity-25 text-red-400;
     }
 
+    &.minizel {
+      @apply border-purple-500 bg-purple-500 bg-opacity-25 text-purple-400;
+    }
+
     &:hover {
       @apply bg-opacity-50 text-white;
     }
diff --git a/apps/ferret/src/components/Modal.svelte b/apps/ferret/src/components/Modal.svelte
index bc5a30bb..0bb0419d 100644
--- a/apps/ferret/src/components/Modal.svelte
+++ b/apps/ferret/src/components/Modal.svelte
@@ -2,7 +2,7 @@
   import type { Snippet } from 'svelte';
 
   interface Props {
-    title: string;
+    title: string | Snippet;
     subtitle?: string;
     children?: Snippet;
     buttons?: Snippet;
@@ -13,7 +13,13 @@
 
 <div class="z-10 flex w-full flex-col gap-4 overflow-y-auto p-6">
   <div class=" self-stretch leading-tight">
-    <h2 class="font-display text-xl font-bold text-neutral-100 sm:text-2xl">{title}</h2>
+    <h2 class="font-display text-xl font-bold text-neutral-100 sm:text-2xl">
+      {#if typeof title === 'string'}
+        {title}
+      {:else}
+        {@render title?.()}
+      {/if}
+    </h2>
     {#if subtitle}
       <span class="text-sm sm:text-base">
         {subtitle}
diff --git a/apps/ferret/src/lib/device.ts b/apps/ferret/src/lib/device.ts
index 6428a31c..3a4ca2e6 100644
--- a/apps/ferret/src/lib/device.ts
+++ b/apps/ferret/src/lib/device.ts
@@ -1,6 +1,30 @@
 import { browser } from '$app/environment';
+import { writable } from 'svelte/store';
 
-const device = {
+interface DeviceInfo {
+  userAgent: string;
+  platform: {
+    windows: boolean;
+    mac: boolean;
+    unix: boolean;
+    iphone: boolean;
+    android: boolean;
+    mobile: boolean;
+    desktop: boolean;
+  };
+  prefers: {
+    language: string;
+    reducedMotion: boolean;
+    reducedTransparency: boolean;
+  };
+  capabilities: {
+    showSaveFilePicker: boolean;
+    showDirectoryPicker: boolean;
+    minizel: boolean;
+  };
+}
+
+const defaultDevice: DeviceInfo = {
   userAgent: '(SvelteKit server render)',
   platform: {
     windows: false,
@@ -15,39 +39,72 @@ const device = {
     language: 'en',
     reducedMotion: false,
     reducedTransparency: false
+  },
+  capabilities: {
+    showSaveFilePicker: false,
+    showDirectoryPicker: false,
+    minizel: false
   }
 };
 
-export type DevicePlatform = keyof (typeof device)['platform'];
+/** Reactive device store for use in Svelte components */
+export const device = writable<DeviceInfo>({ ...defaultDevice });
+
+export type DevicePlatform = keyof DeviceInfo['platform'];
+export type DeviceCapability = keyof DeviceInfo['capabilities'];
 
 export function processUserAgent(userAgent: string) {
   const ua = userAgent.toLowerCase();
 
   const iphone = ua.includes('iphone os');
   const android = ua.includes('android');
-  device.platform = {
-    windows: ua.includes('windows nt'),
-    mac: ua.includes('mac os x') && !iphone,
-    unix: (ua.includes('linux') || ua.includes('bsd')) && !android,
+  const firefox = ua.includes('firefox');
+
+  device.update((d) => ({
+    ...d,
+    userAgent,
+    platform: {
+      windows: ua.includes('windows nt'),
+      mac: ua.includes('mac os x') && !iphone,
+      unix: (ua.includes('linux') || ua.includes('bsd')) && !android,
+      iphone,
+      android,
+      mobile: iphone || android,
+      desktop: !(iphone || android)
+    },
+    capabilities: {
+      showSaveFilePicker: !firefox,
+      showDirectoryPicker: !firefox,
+      minizel: !firefox
+    }
+  }));
+}
 
-    iphone,
-    android,
+/** Refresh device capabilities - call once after mount to ensure reactivity */
+export function refreshDeviceCapabilities() {
+  if (!browser) return;
 
-    mobile: iphone || android,
-    desktop: !(iphone || android)
-  };
+  device.update((d) => {
+    const hasShowSaveFilePicker = typeof window.showSaveFilePicker === 'function';
+    const hasShowDirectoryPicker = typeof window.showDirectoryPicker === 'function';
 
-  device.userAgent = userAgent;
+    return {
+      ...d,
+      prefers: {
+        language: navigator.language.toLowerCase().slice(0, 2) || 'en',
+        reducedMotion: window.matchMedia('(prefers-reduced-motion: reduce)').matches,
+        reducedTransparency: window.matchMedia('(prefers-reduced-transparency: reduce)').matches
+      },
+      capabilities: {
+        showSaveFilePicker: hasShowSaveFilePicker,
+        showDirectoryPicker: hasShowDirectoryPicker,
+        minizel: hasShowSaveFilePicker
+      }
+    };
+  });
 }
 
 if (browser) {
-  processUserAgent(navigator.userAgent.toLowerCase());
-
-  device.prefers = {
-    language: navigator.language.toLowerCase().slice(0, 2) || 'en',
-    reducedMotion: window.matchMedia('(prefers-reduced-motion: reduce)').matches,
-    reducedTransparency: window.matchMedia('(prefers-reduced-transparency: reduce)').matches
-  };
+  processUserAgent(navigator.userAgent);
+  refreshDeviceCapabilities();
 }
-
-export { device };
diff --git a/apps/ferret/src/lib/minizel/bitstream.ts b/apps/ferret/src/lib/minizel/bitstream.ts
new file mode 100644
index 00000000..4d454972
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/bitstream.ts
@@ -0,0 +1,78 @@
+export class Bitstream {
+  /** Current offset in bits. */
+  pos = 0;
+
+  constructor(public bytes: Uint8Array) {}
+
+  seekToByte(byteOffset: number) {
+    this.pos = 8 * byteOffset;
+  }
+
+  private readBit() {
+    const byteIndex = Math.floor(this.pos / 8);
+    const byte = this.bytes[byteIndex] ?? 0;
+    const bitIndex = 0b111 - (this.pos & 0b111);
+    const bit = (byte & (1 << bitIndex)) >> bitIndex;
+
+    this.pos++;
+    return bit;
+  }
+
+  readBits(n: number) {
+    if (n === 1) {
+      return this.readBit();
+    }
+
+    let result = 0;
+
+    for (let i = 0; i < n; i++) {
+      result <<= 1;
+      result |= this.readBit();
+    }
+
+    return result;
+  }
+
+  writeBits(n: number, value: number) {
+    const end = this.pos + n;
+
+    for (let i = this.pos; i < end; i++) {
+      const byteIndex = Math.floor(i / 8);
+      let byte = this.bytes[byteIndex]!;
+      const bitIndex = 0b111 - (this.pos & 0b111);
+
+      byte &= ~(1 << bitIndex);
+      byte |= ((value & (1 << (end - i - 1))) >> (end - i - 1)) << bitIndex;
+      this.bytes[byteIndex] = byte;
+    }
+
+    this.pos = end;
+  }
+
+  readAlignedByte() {
+    // Ensure we're byte-aligned
+    if (this.pos % 8 !== 0) {
+      throw new Error('Bitstream is not byte-aligned.');
+    }
+
+    const byteIndex = this.pos / 8;
+    const byte = this.bytes[byteIndex] ?? 0;
+
+    this.pos += 8;
+    return byte;
+  }
+
+  skipBits(n: number) {
+    this.pos += n;
+  }
+
+  getBitsLeft() {
+    return this.bytes.length * 8 - this.pos;
+  }
+
+  clone() {
+    const clone = new Bitstream(this.bytes);
+    clone.pos = this.pos;
+    return clone;
+  }
+}
diff --git a/apps/ferret/src/lib/minizel/index.ts b/apps/ferret/src/lib/minizel/index.ts
new file mode 100644
index 00000000..2761d8b2
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/index.ts
@@ -0,0 +1,7 @@
+export { Bitstream } from './bitstream';
+export { LibAVFlacEncoder } from './libav-flac-encoder';
+export { MixedProcessor, type MixedProcessorOptions } from './mixed-processor';
+export type { PageMeta, WorkerMessage } from './oggParser.worker';
+export { MinizelProcessor, type MinizelProcessorOptions, type TrackStats } from './processor';
+export { createResilientStream, type ResilientFetchOptions } from './resilientFetch';
+export { convertToTimeMark, formatBytes, type MinizelFormat } from './util';
diff --git a/apps/ferret/src/lib/minizel/libav-flac-encoder.ts b/apps/ferret/src/lib/minizel/libav-flac-encoder.ts
new file mode 100644
index 00000000..72059a14
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/libav-flac-encoder.ts
@@ -0,0 +1,153 @@
+import { newQueue } from '@henrygd/queue';
+import LibAV from '@libav.js/variant-webcodecs';
+import { type AudioCodec, AudioSample, CustomAudioEncoder, EncodedPacket } from 'mediabunny';
+
+import { Bitstream } from './bitstream';
+
+const FLAC_HEADER = new Uint8Array([0x66, 0x4c, 0x61, 0x43]);
+
+export class LibAVFlacEncoder extends CustomAudioEncoder {
+  private _libav?: LibAV.LibAV;
+  private _c?: number;
+  private _frame?: number;
+  private _pkt?: number;
+  private _q = newQueue(1);
+  private meta?: EncodedAudioChunkMetadata;
+
+  static override supports(codec: AudioCodec, config: AudioDecoderConfig): boolean {
+    return codec === 'flac' && config.numberOfChannels === 2;
+  }
+
+  async init() {
+    this._libav = await LibAV.LibAV({
+      variant: 'webcodecs',
+      base: '/_libav'
+    });
+  }
+
+  #toS16(audioSample: AudioSample) {
+    const arrayBuffer = new ArrayBuffer(audioSample.allocationSize({ planeIndex: 0, format: 's16' }));
+    audioSample.copyTo(arrayBuffer, { planeIndex: 0, format: 's16' });
+    return new Int16Array(arrayBuffer);
+  }
+
+  async #getMeta(audioSample: AudioSample) {
+    if (this.meta) return this.meta;
+    const extradataPtr = await this._libav!.AVCodecContext_extradata(this._c!);
+    const extradata_size = await this._libav!.AVCodecContext_extradata_size(this._c!);
+    let description: Uint8Array | undefined = undefined;
+    if (extradataPtr && extradata_size) {
+      const meta = await this._libav!.copyout_u8(extradataPtr, extradata_size);
+      const headerBitstream = new Bitstream(new Uint8Array(4));
+      headerBitstream.writeBits(1, 1); // isLastMetadata
+      headerBitstream.writeBits(7, 0); // metaBlockType = streaminfo
+      headerBitstream.writeBits(24, meta.length); // size
+      description = new Uint8Array(4 + 4 + meta.length);
+      description.set(FLAC_HEADER, 0);
+      description.set(headerBitstream.bytes, 4);
+      description.set(meta, 8);
+    }
+
+    this.meta = {
+      decoderConfig: {
+        sampleRate: audioSample.sampleRate,
+        numberOfChannels: audioSample.numberOfChannels,
+        codec: 'flac',
+        description
+      }
+    };
+    return this.meta;
+  }
+
+  async encode(audioSample: AudioSample) {
+    if (!this._libav) throw new TypeError('No LibAV');
+
+    const format = LibAV.AV_SAMPLE_FMT_S16;
+    const raw = this.#toS16(audioSample);
+    const nb_samples = audioSample.allocationSize({ planeIndex: 0, format: 'u8-planar' });
+
+    // Convert the timestamp
+    const [pts, ptshi] = LibAV.f64toi64(audioSample.timestamp);
+
+    // Convert the channel layout
+    const cc = audioSample.numberOfChannels;
+    const channel_layout = cc === 1 ? 4 : (1 << cc) - 1;
+
+    // Make the frame
+    const sample_rate = audioSample.sampleRate;
+    const frame: LibAV.Frame = {
+      data: raw,
+      format,
+      pts,
+      ptshi,
+      channel_layout,
+      sample_rate,
+      nb_samples
+    };
+
+    return this._q.add(async () => {
+      if (!this._libav) throw new TypeError('No LibAV');
+      if (!this._c) {
+        const [, c, frame, pkt] = await this._libav.ff_init_encoder('flac', {
+          ctx: {
+            sample_fmt: LibAV.AV_SAMPLE_FMT_S16,
+            bit_rate: 0,
+            sample_rate,
+            channel_layout,
+            channels: cc,
+            frame_size: 0
+          },
+          time_base: [1, sample_rate]
+        });
+
+        this._c = c;
+        this._frame = frame;
+        this._pkt = pkt;
+      }
+
+      // Set the current frame size to match this frame's nb_samples
+      await this._libav.AVCodecContext_frame_size_s(this._c!, nb_samples);
+
+      const encodedOutputs = await this._libav.ff_encode_multi(this._c!, this._frame!, this._pkt!, [frame]);
+      for (const packet of encodedOutputs)
+        this.onPacket(
+          new EncodedPacket(
+            packet.data,
+            'key',
+            packet.time_base_num! / packet.time_base_den!,
+            LibAV.i64tof64(packet.duration!, packet.durationhi || 0) / 1000
+          ),
+          await this.#getMeta(audioSample)
+        );
+    });
+  }
+
+  async flush() {
+    this._q.add(async () => {
+      if (!this._libav) throw new TypeError('No LibAV');
+      const encodedOutputs = await this._libav.ff_encode_multi(this._c!, this._frame!, this._pkt!, [], true);
+      for (const packet of encodedOutputs)
+        if (packet.data.length)
+          this.onPacket(
+            new EncodedPacket(
+              packet.data,
+              'key',
+              packet.time_base_num! / packet.time_base_den!,
+              LibAV.i64tof64(packet.duration!, packet.durationhi || 0) / 1000
+            ),
+            this.meta!
+          );
+    });
+    await this._q.done();
+  }
+
+  async close() {
+    if (this._c) {
+      this._q.clear();
+      await this._libav?.ff_free_encoder(this._c!, this._frame!, this._pkt!);
+      this._c = this._frame = this._pkt = 0;
+    }
+    this._libav?.worker?.terminate();
+    this._libav = undefined;
+  }
+}
diff --git a/apps/ferret/src/lib/minizel/mixed-processor.ts b/apps/ferret/src/lib/minizel/mixed-processor.ts
new file mode 100644
index 00000000..01cfc790
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/mixed-processor.ts
@@ -0,0 +1,504 @@
+import { newQueue } from '@henrygd/queue';
+import { FLACDecoderWebWorker } from '@wasm-audio-decoders/flac';
+import {
+  AdtsOutputFormat,
+  AudioSample,
+  AudioSampleSource,
+  canEncodeAudio,
+  FlacOutputFormat,
+  Output,
+  QUALITY_HIGH,
+  StreamTarget,
+  type StreamTargetChunk,
+  WavOutputFormat
+} from 'mediabunny';
+import { OpusDecoderWebWorker } from 'opus-decoder';
+
+import type { PageMeta, WorkerMessage } from './oggParser.worker';
+import {
+  bytesEqual,
+  CHUNK_SIZE,
+  FLAC,
+  HIGH_WATERMARK,
+  LOW_WATERMARK,
+  type MinizelFormat,
+  MIX_BUFFER_SECONDS,
+  MIX_STEP,
+  OPUS,
+  SAMPLE_RATE
+} from './util';
+
+type MixFormat = Exclude<MinizelFormat, 'ogg'>;
+
+type MixPacket = {
+  left: Float32Array;
+  right: Float32Array;
+  granulePosition: number;
+};
+
+export interface MixedProcessorOptions {
+  reader: ReadableStreamDefaultReader<Uint8Array>;
+  fileHandle: FileSystemFileHandle;
+  format: MixFormat;
+  excludedTracks?: Set<number>;
+  onProgress?: () => void;
+}
+
+/**
+ * Resample audio buffer from one sample rate to another using linear interpolation
+ */
+function resampleAudioBuffer(channelData: Float32Array[], fromRate: number, toRate: number): Float32Array[] {
+  if (fromRate === toRate) return channelData;
+  const ratio = toRate / fromRate;
+  const newLength = Math.round(channelData[0]!.length * ratio);
+  return channelData.map((channel) => {
+    const newChannel = new Float32Array(newLength);
+    for (let i = 0; i < newLength; i++) {
+      const srcIdx = i / ratio;
+      const srcIdxInt = Math.floor(srcIdx);
+      const frac = srcIdx - srcIdxInt;
+      if (srcIdxInt + 1 < channel.length) {
+        newChannel[i] = (1 - frac) * channel[srcIdxInt]! + frac * channel[srcIdxInt + 1]!;
+      } else {
+        newChannel[i] = channel[srcIdxInt]!;
+      }
+    }
+    return newChannel;
+  });
+}
+
+export class MixedProcessor {
+  private reader: ReadableStreamDefaultReader<Uint8Array>;
+  private format: MixFormat;
+  private fileHandle: FileSystemFileHandle;
+  private excludedTracks: Set<number>;
+  private readerPaused = false;
+  private readerPausedResolve: (() => void) | null = null;
+  private _workerDone: (() => void) | null = null;
+  private aborted = false;
+
+  // Stream state
+  private streamTypes = new Map<number, 'opus' | 'flac'>();
+  private streamFlacRates = new Map<number, number>();
+  private granuleOffset: bigint | null = null;
+  private streamPositions = new Map<number, bigint>();
+
+  // Stats
+  outstandingNetworkBytes = 0;
+  downloadedBytes = 0;
+  bytesWritten = 0;
+  currentMixPosition = 0;
+  samplesWritten = 0;
+  packetsDecoded = 0;
+  pagesReceived = 0;
+
+  // Decoders
+  private opusDecoder: OpusDecoderWebWorker<48000> | null = null;
+  private flacDecoder: FLACDecoderWebWorker | null = null;
+
+  // MediaBunny output
+  private mbOutput: Output | null = null;
+  private mbSampleSource: AudioSampleSource | null = null;
+  private queue = newQueue(1);
+  private decodingQueue = newQueue(1);
+
+  // Mix buffer - bounded to prevent unbounded growth
+  private mixCache: MixPacket[] = [];
+  private maxMixCacheSamples = SAMPLE_RATE * MIX_BUFFER_SECONDS;
+
+  // Callbacks
+  onProgress?: () => void;
+  onFinish?: () => void;
+
+  constructor(options: MixedProcessorOptions) {
+    this.reader = options.reader;
+    this.fileHandle = options.fileHandle;
+    this.format = options.format;
+    this.excludedTracks = options.excludedTracks ?? new Set();
+    this.onProgress = options.onProgress;
+  }
+
+  /** Check if a track is excluded */
+  isTrackExcluded(serial: number): boolean {
+    return this.excludedTracks.has(serial);
+  }
+
+  /** Estimate queued bytes for backpressure (includes network buffer + decoded mix cache) */
+  estimatedQueuedBytes(): number {
+    // Calculate approximate size of mix cache (Float32Array = 4 bytes per sample, 2 channels)
+    const mixCacheBytes = this.mixCache.reduce((sum, packet) => {
+      return sum + packet.left.length * 4 + packet.right.length * 4;
+    }, 0);
+    return this.outstandingNetworkBytes + mixCacheBytes;
+  }
+
+  /** Abort processing */
+  abort(): void {
+    this.aborted = true;
+    if (this.readerPausedResolve) {
+      this.readerPausedResolve();
+      this.readerPausedResolve = null;
+    }
+  }
+
+  async cleanup(): Promise<void> {
+    try {
+      await this.mbOutput?.cancel();
+    } catch {}
+
+    try {
+      const writable = await this.fileHandle.createWritable();
+      await writable.truncate(0);
+      await writable.close();
+    } catch {}
+  }
+
+  private checkResume(): void {
+    if (this.readerPaused && this.estimatedQueuedBytes() <= LOW_WATERMARK) {
+      this.readerPaused = false;
+      if (this.readerPausedResolve) {
+        const r = this.readerPausedResolve;
+        this.readerPausedResolve = null;
+        r();
+      }
+    }
+  }
+
+  private async ensureOutput(): Promise<void> {
+    if (this.mbSampleSource) return;
+
+    const output = new Output({
+      format: this.format === 'aac' ? new AdtsOutputFormat() : this.format === 'flac' ? new FlacOutputFormat() : new WavOutputFormat({ large: true }),
+      target: await this.createStreamTarget(await this.fileHandle.createWritable(), (pos, len) => {
+        this.bytesWritten = Math.max(this.bytesWritten, pos + len);
+      })
+    });
+
+    const audioSource = new AudioSampleSource({
+      codec: this.format === 'wav' ? 'pcm-f32' : this.format,
+      bitrate: QUALITY_HIGH
+    });
+    output.addAudioTrack(audioSource);
+    await output.start();
+    this.mbOutput = output;
+    this.mbSampleSource = audioSource;
+  }
+
+  private async createStreamTarget(writer: FileSystemWritableFileStream, onWrite?: (pos: number, dataLength: number) => void): Promise<StreamTarget> {
+    const writable = new WritableStream({
+      async write(chunk: StreamTargetChunk) {
+        await writer.write({ type: 'write', position: chunk.position, data: chunk.data as BufferSource });
+        onWrite?.(chunk.position, chunk.data.byteLength);
+      },
+      close() {
+        writer.close();
+      },
+      async abort() {
+        await writer.abort();
+      }
+    });
+    return new StreamTarget(writable, { chunked: true, chunkSize: CHUNK_SIZE });
+  }
+
+  private async enqueueSample(left: Float32Array, right: Float32Array, startPosition: number): Promise<void> {
+    const blockLength = left.length;
+    this.samplesWritten++;
+    this.queue.add(async () => {
+      const planar = new Float32Array(blockLength * 2);
+      planar.set(left, 0);
+      planar.set(right, blockLength);
+
+      const sample = new AudioSample({
+        data: planar,
+        format: 'f32-planar',
+        numberOfChannels: 2,
+        sampleRate: SAMPLE_RATE,
+        timestamp: startPosition / SAMPLE_RATE
+      });
+
+      try {
+        await this.mbSampleSource!.add(sample);
+      } finally {
+        sample.close();
+      }
+    });
+  }
+
+  private pruneMixCache(): void {
+    // Remove packets that are too far behind current write position
+    const cutoff = this.currentMixPosition - this.maxMixCacheSamples;
+    this.mixCache = this.mixCache.filter((packet) => packet.granulePosition + packet.left.length > cutoff);
+  }
+
+  private async processMix(finalize = false): Promise<void> {
+    while (true) {
+      if (this.mixCache.length === 0) break;
+
+      // Prune old packets
+      this.pruneMixCache();
+      if (this.mixCache.length === 0) break;
+
+      const ordered = [...this.mixCache].sort((a, b) => a.granulePosition - b.granulePosition);
+      const minStart = ordered[0]!.granulePosition;
+      const maxStart = ordered[ordered.length - 1]!.granulePosition;
+      const range = maxStart - minStart;
+
+      const blockStart = this.currentMixPosition;
+      const blockEnd = blockStart + MIX_STEP;
+
+      // Calculate the latest end position of any packet
+      const latestEnd = this.mixCache.reduce((max, packet) => {
+        const packetEnd = packet.granulePosition + packet.left.length;
+        return packetEnd > max ? packetEnd : max;
+      }, 0);
+
+      // Wait for more data if the mix cache is not full
+      const shouldMix = range > SAMPLE_RATE * MIX_BUFFER_SECONDS;
+      if (!finalize && !shouldMix) {
+        const bufferAhead = latestEnd - blockStart;
+        const minBufferSamples = SAMPLE_RATE * 0.5;
+        if (bufferAhead < minBufferSamples) break;
+      }
+
+      // If data is ahead, fill with silence
+      if (minStart >= blockEnd) {
+        const gap = minStart - blockStart;
+        const blocksToFill = finalize ? Math.ceil(gap / MIX_STEP) : Math.floor(gap / MIX_STEP);
+        if (!finalize && blocksToFill === 0) break;
+
+        for (let i = 0; i < blocksToFill; i++) {
+          const zeroLeft = new Float32Array(MIX_STEP);
+          const zeroRight = new Float32Array(MIX_STEP);
+          await this.enqueueSample(zeroLeft, zeroRight, this.currentMixPosition);
+          this.currentMixPosition += MIX_STEP;
+        }
+        continue;
+      }
+
+      // Mix all overlapping packets into this block
+      const blockLeft = new Float32Array(MIX_STEP);
+      const blockRight = new Float32Array(MIX_STEP);
+      let audioAdded = false;
+
+      for (const packet of this.mixCache) {
+        const packetStart = packet.granulePosition;
+        const packetEnd = packetStart + packet.left.length;
+
+        if (packetEnd <= blockStart || packetStart >= blockEnd) continue;
+
+        audioAdded = true;
+
+        const overlapStart = Math.max(blockStart, packetStart);
+        const overlapEnd = Math.min(blockEnd, packetEnd);
+        const srcOffset = overlapStart - packetStart;
+        const destOffset = overlapStart - blockStart;
+        const overlapLength = overlapEnd - overlapStart;
+
+        for (let i = 0; i < overlapLength; i++) {
+          blockLeft[destOffset + i]! += packet.left[srcOffset + i]!;
+          blockRight[destOffset + i]! += packet.right[srcOffset + i]!;
+        }
+      }
+
+      // wait for more data if nothing mixed and we are fine
+      if (!audioAdded && !finalize && !shouldMix) break;
+
+      await this.enqueueSample(blockLeft, blockRight, blockStart);
+      this.currentMixPosition += MIX_STEP;
+      this.onProgress?.();
+    }
+  }
+
+  private onWorkerMessage(msg: WorkerMessage): void {
+    if (this.aborted) return;
+
+    if (msg.type === 'page') {
+      this.pagesReceived++;
+      const pageBuf = new Uint8Array(msg.page);
+      const meta: PageMeta = msg.meta;
+      this.outstandingNetworkBytes = Math.max(0, this.outstandingNetworkBytes - meta.payloadLength);
+
+      const serial = meta.serial;
+
+      if (this.isTrackExcluded(serial)) {
+        this.checkResume();
+        return;
+      }
+
+      const pageSegments = pageBuf[26]!;
+      const headerTotalLen = 27 + pageSegments;
+      // Copy payload to avoid issues with transferred buffer
+      const payload = pageBuf.slice(headerTotalLen);
+      const granulePosition = BigInt(meta.granulePosition);
+
+      // Determine stream type if header
+      if (granulePosition === 0n) {
+        if (payload.length < 5) return;
+        if (bytesEqual(payload.subarray(0, 4), OPUS)) {
+          this.streamTypes.set(serial, 'opus');
+        } else if (bytesEqual(payload.subarray(0, 5), FLAC)) {
+          this.streamTypes.set(serial, 'flac');
+          if (payload.length > 29) {
+            const flacRate = (payload[27]! << 12) + (payload[28]! << 4) + (payload[29]! >> 4);
+            this.streamFlacRates.set(serial, flacRate);
+          }
+        }
+        return;
+      }
+
+      if (!this.granuleOffset) this.granuleOffset = granulePosition;
+      if (payload.length <= 1) return;
+
+      const type = this.streamTypes.get(serial);
+      if (!type) return;
+
+      // Queue decoding (payload is already copied above)
+      this.decodingQueue.add(async () => {
+        if (this.aborted) return;
+
+        const currentPosition = this.streamPositions.get(serial) ?? this.granuleOffset!;
+        let chosenStartPosition = currentPosition;
+
+        // Packet far behind: drop
+        if (currentPosition > granulePosition + BigInt(960 * 25)) {
+          console.debug(`[Minizel] Dropping packet: too far behind (current: ${currentPosition}, granule: ${granulePosition})`);
+          return;
+        }
+
+        // Packet far ahead: set position
+        if (currentPosition + 960n * 25n < granulePosition) chosenStartPosition = granulePosition;
+
+        // Decode
+        this.packetsDecoded++;
+        const decoded = type === 'opus' ? await this.opusDecoder!.decodeFrame(payload) : await this.flacDecoder!.decode(payload);
+        let channelData = decoded.channelData;
+
+        // Resample if needed
+        if (decoded.sampleRate !== SAMPLE_RATE) channelData = resampleAudioBuffer(channelData, decoded.sampleRate, SAMPLE_RATE);
+
+        // Add to mix cache (bounded)
+        const startPosition = Number(chosenStartPosition - this.granuleOffset!);
+        this.mixCache.push({
+          left: channelData[0]!,
+          right: channelData[1]!,
+          granulePosition: startPosition
+        });
+        this.streamPositions.set(serial, chosenStartPosition + BigInt(channelData[0]!.length));
+
+        // Process mix
+        await this.processMix();
+
+        // Update progress after processing
+        this.onProgress?.();
+
+        // Check resume
+        if (this.readerPaused && this.estimatedQueuedBytes() <= LOW_WATERMARK) {
+          this.readerPaused = false;
+          if (this.readerPausedResolve) {
+            this.readerPausedResolve();
+            this.readerPausedResolve = null;
+          }
+        }
+      });
+    } else if (msg.type === 'consumed') {
+      this.outstandingNetworkBytes = Math.max(0, this.outstandingNetworkBytes - (msg.consumed ?? 0));
+      this.checkResume();
+    } else if (msg.type === 'error') {
+      console.error('Mixed worker error', msg.message);
+    } else if (msg.type === 'done') {
+      this._workerDone?.();
+    }
+  }
+
+  async start(): Promise<void> {
+    this.opusDecoder = new OpusDecoderWebWorker({ forceStereo: true, sampleRate: 48_000 });
+    this.flacDecoder = new FLACDecoderWebWorker();
+    await Promise.all([this.opusDecoder.ready, this.flacDecoder.ready]);
+
+    const canDo = await canEncodeAudio(this.format === 'wav' ? 'pcm-f32' : this.format, {
+      numberOfChannels: 2,
+      sampleRate: 48_000
+    });
+    if (!canDo) throw new Error(`Browser cannot encode ${this.format} audio`);
+
+    await this.ensureOutput();
+
+    const worker = new Worker(new URL('./oggParser.worker.ts', import.meta.url), {
+      type: 'module',
+      name: 'ogg-parser'
+    });
+    const waitForWorker = new Promise<void>((resolve) => (this._workerDone = resolve));
+    worker.addEventListener('message', (ev: MessageEvent) => this.onWorkerMessage(ev.data));
+
+    try {
+      try {
+        while (!this.aborted) {
+          const { done, value } = await this.reader.read();
+          if (done) {
+            worker.postMessage({ type: 'end' });
+            break;
+          }
+          if (!value) continue;
+
+          this.outstandingNetworkBytes += value.byteLength;
+          this.downloadedBytes += value.byteLength;
+          worker.postMessage({ type: 'chunk', chunk: value.buffer }, [value.buffer]);
+          this.onProgress?.();
+
+          // Backpressure
+          if (this.estimatedQueuedBytes() > HIGH_WATERMARK) {
+            this.readerPaused = true;
+            await new Promise<void>((resolve) => (this.readerPausedResolve = resolve));
+          }
+        }
+      } finally {
+        try {
+          this.reader.releaseLock();
+        } catch {}
+      }
+
+      if (!this.aborted) await waitForWorker;
+      worker.terminate();
+
+      console.debug(`[Minizel] Worker done. Pages: ${this.pagesReceived}, Streams: ${this.streamTypes.size}`);
+
+      // Wait for decoding to finish
+      await this.decodingQueue.done();
+
+      console.debug(`[Minizel] Decoding done. Packets decoded: ${this.packetsDecoded}, Mix cache size: ${this.mixCache.length}`);
+
+      await this.opusDecoder?.free();
+      this.opusDecoder = null;
+      await this.flacDecoder?.free();
+      this.flacDecoder = null;
+
+      // Process remaining packets
+      const cacheBeforeFinalize = this.mixCache.length;
+      await this.processMix(true);
+
+      console.debug(`[Minizel] Final mix done. Cache before: ${cacheBeforeFinalize}, Samples written: ${this.samplesWritten}, Position: ${this.currentMixPosition}`);
+
+      // Finalize output
+      await this.queue.done();
+      await this.mbOutput!.finalize();
+
+      console.debug(`[Minizel] Output finalized. Bytes written: ${this.bytesWritten}`);
+
+      // Final progress update
+      this.onProgress?.();
+      this.onFinish?.();
+    } catch (e) {
+      console.error('Mixed processor error!', e);
+      worker.terminate();
+      this.queue.clear();
+      this.decodingQueue.clear();
+      await this.mbOutput?.cancel();
+      this.mbSampleSource?.close();
+      await this.opusDecoder?.free();
+      this.opusDecoder = null;
+      await this.flacDecoder?.free();
+      this.flacDecoder = null;
+      throw e;
+    }
+  }
+}
diff --git a/apps/ferret/src/lib/minizel/ogg.ts b/apps/ferret/src/lib/minizel/ogg.ts
new file mode 100644
index 00000000..e698b392
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/ogg.ts
@@ -0,0 +1,83 @@
+/** OGG capture pattern 'OggS' as little-endian uint32 */
+export const OGGS = 0x5367674f;
+
+export const MIN_PAGE_HEADER_SIZE = 27;
+export const MAX_PAGE_HEADER_SIZE = 27 + 255;
+export const MAX_PAGE_SIZE = MAX_PAGE_HEADER_SIZE + 255 * 255;
+
+/** CRC polynomial for OGG */
+const OGG_CRC_POLYNOMIAL = 0x04c11db7;
+
+/** Pre-computed CRC lookup table */
+export const OGG_CRC_TABLE = new Uint32Array(256);
+for (let n = 0; n < 256; n++) {
+  let crc = n << 24;
+  for (let k = 0; k < 8; k++) {
+    crc = crc & 0x80000000 ? (crc << 1) ^ OGG_CRC_POLYNOMIAL : crc << 1;
+  }
+  OGG_CRC_TABLE[n] = (crc >>> 0) & 0xffffffff;
+}
+
+/** Compute CRC32 checksum for an OGG page */
+export function computeOggPageCrc(bytes: Uint8Array): number {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+
+  const originalChecksum = view.getUint32(22, true);
+  view.setUint32(22, 0, true); // Zero out checksum field
+
+  let crc = 0;
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i]!;
+    crc = ((crc << 8) ^ OGG_CRC_TABLE[(crc >>> 24) ^ byte]!) >>> 0;
+  }
+
+  view.setUint32(22, originalChecksum, true); // Restore checksum field
+  return crc;
+}
+
+export interface OggPageData {
+  version: number;
+  headerType: number;
+  granulePosition: bigint;
+  bitstreamSerialNumber: number;
+  pageSequenceNumber: number;
+  payload: Uint8Array;
+}
+
+/** Create a valid OGG page with proper CRC */
+export function createPage(data: OggPageData): Uint8Array {
+  // Build the segment table
+  const segments: number[] = [];
+  let rem = data.payload.length;
+  while (rem > 0) {
+    const take = Math.min(255, rem);
+    segments.push(take);
+    rem -= take;
+  }
+  if (segments.length === 0) segments.push(0);
+
+  const headerTotalLen = 27 + segments.length;
+  const pageTotalLen = headerTotalLen + data.payload.length;
+
+  // Allocate buffer for page
+  const bytes = new Uint8Array(pageTotalLen);
+  const view = new DataView(bytes.buffer);
+
+  view.setUint32(0, OGGS, true); // Capture pattern
+  view.setUint8(4, data.version); // Version
+  view.setUint8(5, data.headerType); // Header type
+  view.setBigUint64(6, data.granulePosition, true); // Granule position
+  view.setUint32(14, data.bitstreamSerialNumber, true); // Serial number
+  view.setUint32(18, data.pageSequenceNumber, true); // Page sequence number
+  view.setUint32(22, 0, true); // Checksum placeholder
+
+  bytes[26] = segments.length; // Number of page segments
+  bytes.set(segments, 27);
+  bytes.set(data.payload, 27 + segments.length);
+
+  // Compute CRC and write it
+  const crc = computeOggPageCrc(bytes);
+  view.setUint32(22, crc, true);
+
+  return bytes;
+}
diff --git a/apps/ferret/src/lib/minizel/oggParser.worker.ts b/apps/ferret/src/lib/minizel/oggParser.worker.ts
new file mode 100644
index 00000000..487f5ba9
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/oggParser.worker.ts
@@ -0,0 +1,152 @@
+import { OGGS } from './ogg';
+
+type InMsg = { type: 'chunk'; chunk: ArrayBuffer } | { type: 'end' };
+
+export type PageMeta = {
+  serial: number;
+  granulePosition: string; // bigint serialized as string
+  pageSequenceNumber: number;
+  headerType: number;
+  payloadLength: number;
+};
+
+export type WorkerMessage =
+  | { type: 'page'; page: ArrayBuffer; meta: PageMeta }
+  | { type: 'consumed'; consumed: number }
+  | { type: 'error'; message: string }
+  | { type: 'done' };
+
+let buf = new Uint8Array(0);
+
+function appendBuffer(ab: ArrayBuffer): void {
+  const chunk = new Uint8Array(ab);
+  if (buf.length === 0) {
+    buf = chunk;
+    return;
+  }
+  const out = new Uint8Array(buf.length + chunk.length);
+  out.set(buf, 0);
+  out.set(chunk, buf.length);
+  buf = out;
+}
+
+/**
+ * Try to parse as many full OGG pages as possible from the buffer.
+ * For each parsed page, post it back to main thread with transferable buffer.
+ */
+function processBuffer(): void {
+  let pageView = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let consumedTotal = 0;
+
+  const notifyConsumed = (): void => {
+    if (consumedTotal > 0) {
+      try {
+        self.postMessage({ type: 'consumed', consumed: consumedTotal });
+      } catch {
+        /* ignore */
+      }
+    }
+  };
+
+  while (true) {
+    // Search for capture pattern 'OggS'
+    let idx = -1;
+    for (let i = 0; i + 3 < buf.length; i++) {
+      if (pageView.getUint32(i, true) === OGGS) {
+        idx = i;
+        break;
+      }
+    }
+
+    if (idx === -1) {
+      // Keep last 3 bytes in case 'OggS' spans a boundary
+      if (buf.length > 3) buf = buf.slice(buf.length - 3);
+      notifyConsumed();
+      return;
+    }
+
+    if (idx > 0) {
+      buf = buf.slice(idx);
+      pageView = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+      idx = 0;
+    }
+
+    const BASE_HEADER_LEN = 27;
+    if (buf.length < BASE_HEADER_LEN) {
+      notifyConsumed();
+      return;
+    }
+
+    const pageSegments = buf[26]!;
+    const headerTotalLen = BASE_HEADER_LEN + pageSegments;
+    if (buf.length < headerTotalLen) {
+      notifyConsumed();
+      return;
+    }
+
+    // Read segment table
+    let payloadLen = 0;
+    for (let i = 0; i < pageSegments; i++) {
+      payloadLen += buf[BASE_HEADER_LEN + i]!;
+    }
+
+    const pageTotalLen = headerTotalLen + payloadLen;
+    if (buf.length < pageTotalLen) {
+      notifyConsumed();
+      return;
+    }
+
+    // We have a full page
+    const pageBytes = buf.slice(0, pageTotalLen);
+    const payload = pageBytes.slice(headerTotalLen, pageTotalLen);
+
+    // Parse header fields
+    const headerType = pageBytes[5]!;
+    const granulePosition = pageView.getBigUint64(6, true);
+    const bitstreamSerialNumber = pageView.getUint32(14, true);
+    const pageSequenceNumber = pageView.getUint32(18, true);
+
+    try {
+      const meta: PageMeta = {
+        serial: bitstreamSerialNumber,
+        granulePosition: granulePosition.toString(),
+        pageSequenceNumber,
+        headerType,
+        payloadLength: payload.length
+      };
+
+      // Transfer the buffer to avoid copies
+      self.postMessage({ type: 'page', page: pageBytes.buffer, meta }, { transfer: [pageBytes.buffer] });
+    } catch (err) {
+      self.postMessage({ type: 'error', message: String(err) });
+    }
+
+    // Remove consumed bytes from buffer
+    buf = buf.slice(pageTotalLen);
+    consumedTotal += pageTotalLen;
+    if (buf.length === 0) {
+      notifyConsumed();
+      return;
+    }
+    pageView = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+}
+
+self.addEventListener('message', (ev: MessageEvent<InMsg>) => {
+  const msg = ev.data;
+  if (msg.type === 'chunk') {
+    try {
+      appendBuffer(msg.chunk);
+      processBuffer();
+    } catch (err) {
+      self.postMessage({ type: 'error', message: String(err) });
+    }
+  } else if (msg.type === 'end') {
+    try {
+      processBuffer();
+      self.postMessage({ type: 'done' });
+    } catch (err) {
+      self.postMessage({ type: 'error', message: String(err) });
+    }
+  }
+});
diff --git a/apps/ferret/src/lib/minizel/opus.ts b/apps/ferret/src/lib/minizel/opus.ts
new file mode 100644
index 00000000..61e003cb
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/opus.ts
@@ -0,0 +1,52 @@
+/** Get the number of frames in an Opus packet */
+export function getFramesInPacket(packet: Uint8Array): number {
+  const toc = packet[0]! & 0x3;
+  switch (toc) {
+    case 0:
+      return 1;
+    case 1:
+    case 2:
+      return 2;
+    case 3: // Signalled
+      return packet[1]! & 0x3f;
+    default:
+      return 1;
+  }
+}
+
+/** Get the frame size (in samples) of an Opus packet */
+export function getFrameSize(packet: Uint8Array): number {
+  const config = packet[0]! >> 3;
+  switch (config) {
+    case 0:
+    case 4:
+    case 8:
+    case 12:
+    case 14:
+    case 18:
+    case 22:
+    case 27:
+    case 30:
+      return 480; // 10ms
+    case 2:
+    case 6:
+    case 10:
+      return 1920; // 40ms
+    case 3:
+    case 7:
+    case 11:
+      return 2880; // 60ms
+    case 17:
+    case 21:
+    case 25:
+    case 29:
+      return 240; // 5ms
+    case 16:
+    case 20:
+    case 24:
+    case 28:
+      return 120; // 2.5ms
+    default:
+      return 960; // 20ms
+  }
+}
diff --git a/apps/ferret/src/lib/minizel/processor.ts b/apps/ferret/src/lib/minizel/processor.ts
new file mode 100644
index 00000000..d7bdd9e6
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/processor.ts
@@ -0,0 +1,636 @@
+import { newQueue, type Queue } from '@henrygd/queue';
+import { FLACDecoderWebWorker } from '@wasm-audio-decoders/flac';
+import {
+  AdtsOutputFormat,
+  AudioSample,
+  AudioSampleSource,
+  canEncodeAudio,
+  FlacOutputFormat,
+  Output,
+  QUALITY_HIGH,
+  StreamTarget,
+  type StreamTargetChunk,
+  WavOutputFormat
+} from 'mediabunny';
+import { OpusDecoderWebWorker } from 'opus-decoder';
+
+import { createPage } from './ogg';
+import type { PageMeta, WorkerMessage } from './oggParser.worker';
+import { getFramesInPacket, getFrameSize } from './opus';
+import {
+  bytesEqual,
+  CHUNK_SIZE,
+  concatUint8Arrays,
+  DEFAULT_PACKET_TIME,
+  FLAC,
+  HIGH_WATERMARK,
+  LOW_WATERMARK,
+  MAX_PENDING_SAMPLES,
+  type MinizelFormat,
+  OPUS,
+  OPUS_TAGS,
+  opusTagsAreIncorrect,
+  SILENT_FLAC_44K,
+  SILENT_FLAC_48K,
+  SILENT_OPUS
+} from './util';
+
+export interface MinizelProcessorOptions {
+  reader: ReadableStreamDefaultReader<Uint8Array>;
+  directoryHandle: FileSystemDirectoryHandle;
+  format: MinizelFormat;
+  excludedTracks?: Set<number>;
+  onFileName?: (serial: number) => string;
+  onTrackDiscovered?: (serial: number, type: 'opus' | 'flac') => void;
+  onProgress?: () => void;
+}
+
+export interface TrackStats {
+  serial: number;
+  type: 'opus' | 'flac';
+  bytesWritten: number;
+  queuedBytes: number;
+  queueSize: number;
+  position: number; // in samples
+}
+
+/**
+ * Bounded queue to limit samples in-flight per track
+ */
+class BoundedQueue {
+  private pending = 0;
+  private waiters: (() => void)[] = [];
+
+  constructor(private maxPending: number = MAX_PENDING_SAMPLES) {}
+
+  async acquire(): Promise<void> {
+    while (this.pending >= this.maxPending) {
+      await new Promise<void>((r) => this.waiters.push(r));
+    }
+    this.pending++;
+  }
+
+  release(): void {
+    this.pending--;
+    this.waiters.shift()?.();
+  }
+
+  get size(): number {
+    return this.pending;
+  }
+}
+
+export class MinizelProcessor {
+  private reader: ReadableStreamDefaultReader<Uint8Array>;
+  private format: MinizelFormat;
+  private excludedTracks: Set<number>;
+  private readerPaused = false;
+  private readerPausedResolve: (() => void) | null = null;
+  private _workerDone: (() => void) | null = null;
+  private aborted = false;
+
+  // File system
+  private directoryHandle: FileSystemDirectoryHandle;
+  private writers = new Map<number, FileSystemWritableFileStream>();
+  private writerCache = new Map<number, Uint8Array[]>();
+
+  // Stream state
+  private streamTypes = new Map<number, 'opus' | 'flac'>();
+  private streamFlacRates = new Map<number, number>();
+  private granuleOffset: bigint | null = null;
+  private positions = new Map<number, bigint>();
+  private lastSequenceNo = new Map<number, number>();
+
+  // Stats
+  outstandingNetworkBytes = 0;
+  downloadedBytes = 0;
+  bytesWritten = new Map<number, number>();
+  private queuedBytes = new Map<number, number>();
+
+  // Decoders
+  private opusDecoder: OpusDecoderWebWorker<48000> | null = null;
+  private flacDecoder: FLACDecoderWebWorker | null = null;
+  private silentAudioBuffer: Float32Array[] | null = null;
+  private silentAudioBuffer44k: Float32Array[] | null = null;
+
+  // MediaBunny outputs
+  private mbOutputs = new Map<number, Output>();
+  private mbSampleSources = new Map<number, AudioSampleSource>();
+  private queues = new Map<number, Queue>();
+  private boundedQueues = new Map<number, BoundedQueue>();
+
+  // Callbacks
+  onFileName?: (serial: number) => string;
+  onTrackDiscovered?: (serial: number, type: 'opus' | 'flac') => void;
+  onProgress?: () => void;
+
+  constructor(options: MinizelProcessorOptions) {
+    this.reader = options.reader;
+    this.directoryHandle = options.directoryHandle;
+    this.format = options.format;
+    this.excludedTracks = options.excludedTracks ?? new Set();
+    this.onFileName = options.onFileName;
+    this.onTrackDiscovered = options.onTrackDiscovered;
+    this.onProgress = options.onProgress;
+  }
+
+  /** Check if a track is excluded */
+  isTrackExcluded(serial: number): boolean {
+    return this.excludedTracks.has(serial);
+  }
+
+  /** Get total bytes queued in memory */
+  totalQueuedBytes(): number {
+    let t = this.outstandingNetworkBytes;
+    for (const c of this.writerCache.values()) {
+      t += c.reduce((p, data) => p + data.byteLength, 0);
+    }
+    for (const b of this.queuedBytes.values()) {
+      t += b;
+    }
+    return t;
+  }
+
+  /** Get stats for all tracks */
+  getTrackStats(): TrackStats[] {
+    const stats: TrackStats[] = [];
+    for (const [serial, type] of this.streamTypes)
+      stats.push({
+        serial,
+        type,
+        bytesWritten: this.bytesWritten.get(serial) ?? 0,
+        queuedBytes: this.queuedBytes.get(serial) ?? 0,
+        queueSize: this.boundedQueues.get(serial)?.size ?? 0,
+        position: Number(this.positions.get(serial) ?? 0n)
+      });
+    return stats.sort((a, b) => a.serial - b.serial);
+  }
+
+  /** Abort processing and clean up created files */
+  abort(): void {
+    this.aborted = true;
+    if (this.readerPausedResolve) {
+      this.readerPausedResolve();
+      this.readerPausedResolve = null;
+    }
+  }
+
+  async cleanup(): Promise<void> {
+    for (const writer of this.writers.values()) {
+      try {
+        await writer.close();
+      } catch {}
+    }
+
+    for (const serial of this.writers.keys()) {
+      const fileName = this.onFileName?.(serial) ?? `track-${serial}.${this.format}`;
+      try {
+        await this.directoryHandle.removeEntry(fileName);
+      } catch {}
+    }
+  }
+
+  private getNextSequenceNumber(streamNo: number): number {
+    if (!this.lastSequenceNo.has(streamNo)) {
+      this.lastSequenceNo.set(streamNo, 0);
+      return 0;
+    }
+    const next = (this.lastSequenceNo.get(streamNo) ?? 0) + 1;
+    this.lastSequenceNo.set(streamNo, next);
+    return next;
+  }
+
+  private checkResume(): void {
+    const totalQueued = this.totalQueuedBytes();
+    if (this.readerPaused && totalQueued <= LOW_WATERMARK) {
+      this.readerPaused = false;
+      if (this.readerPausedResolve) {
+        const r = this.readerPausedResolve;
+        this.readerPausedResolve = null;
+        r();
+      }
+    }
+  }
+
+  private async fileHandleToStreamTarget(handle: FileSystemFileHandle, onWrite?: (pos: number, dataLength: number) => void): Promise<StreamTarget> {
+    const writer = await handle.createWritable();
+    const writable = new WritableStream({
+      async write(chunk: StreamTargetChunk) {
+        await writer.write({ type: 'write', position: chunk.position, data: chunk.data as BufferSource });
+        onWrite?.(chunk.position, chunk.data.byteLength);
+      },
+      close() {
+        writer.close();
+      },
+      async abort() {
+        await writer.abort();
+      }
+    });
+    return new StreamTarget(writable, { chunked: true, chunkSize: CHUNK_SIZE });
+  }
+
+  private writePacket(serial: number, position: bigint, frame?: Uint8Array): void {
+    if (!this.queues.has(serial)) {
+      this.queues.set(serial, newQueue(1));
+      this.boundedQueues.set(serial, new BoundedQueue());
+    }
+
+    const q = this.queues.get(serial)!;
+    const bounded = this.boundedQueues.get(serial)!;
+
+    // Copy the frame if provided since it references a transferred buffer
+    const frameCopy = frame ? frame.slice() : undefined;
+
+    if (frameCopy) {
+      this.queuedBytes.set(serial, (this.queuedBytes.get(serial) ?? 0) + frameCopy.byteLength);
+    }
+
+    q.add(async () => {
+      // Acquire bounded slot inside the queue task
+      await bounded.acquire();
+      try {
+        await this.ensureWriter(serial);
+        const source = this.mbSampleSources.get(serial);
+        if (!source) return;
+
+        let channelData: Float32Array[];
+        let sampleRate: number;
+
+        if (!frameCopy) {
+          // Silent frame
+          const flacRate = this.streamFlacRates.get(serial) ?? 48000;
+          channelData = flacRate === 44100 ? this.silentAudioBuffer44k! : this.silentAudioBuffer!;
+          sampleRate = 48000;
+        } else {
+          // Decode frame
+          const type = this.streamTypes.get(serial)!;
+          const decoded = type === 'opus' ? await this.opusDecoder!.decodeFrame(frameCopy) : await this.flacDecoder!.decode(frameCopy);
+          channelData = decoded.channelData;
+          sampleRate = decoded.sampleRate;
+        }
+
+        // Create sample with proper format - combine channels into planar format
+        const numChannels = channelData.length;
+        const frameCount = channelData[0]!.length;
+        const planarData = new Float32Array(numChannels * frameCount);
+        for (let ch = 0; ch < numChannels; ch++) {
+          planarData.set(channelData[ch]!, ch * frameCount);
+        }
+
+        const sample = new AudioSample({
+          data: planarData,
+          format: 'f32-planar',
+          numberOfChannels: numChannels,
+          sampleRate,
+          timestamp: Number(position) / 48000
+        });
+
+        try {
+          await source.add(sample);
+        } finally {
+          // CRITICAL: Always close sample to free memory
+          sample.close();
+        }
+      } finally {
+        if (frameCopy) {
+          this.queuedBytes.set(serial, Math.max(0, (this.queuedBytes.get(serial) ?? 0) - frameCopy.byteLength));
+        }
+        bounded.release();
+        this.checkResume();
+        this.onProgress?.();
+      }
+    });
+  }
+
+  private writePage(serial: number, chunk: Uint8Array): void {
+    if (!this.queues.has(serial)) {
+      this.queues.set(serial, newQueue(1));
+      this.boundedQueues.set(serial, new BoundedQueue());
+    }
+
+    const q = this.queues.get(serial)!;
+    q.add(async () => {
+      await this.ensureWriter(serial);
+      const cache = this.writerCache.get(serial) ?? [];
+      cache.push(chunk);
+      this.writerCache.set(serial, cache);
+
+      // Flush if over the chunk size
+      const byteLength = cache.reduce((p, data) => p + data.length, 0);
+      if (byteLength > CHUNK_SIZE) {
+        await this.flushWriterCache(serial);
+      }
+      this.onProgress?.();
+    });
+  }
+
+  private async flushWriterCache(serial: number): Promise<void> {
+    const w = this.writers.get(serial);
+    const cache = this.writerCache.get(serial);
+    if (!w || !cache || cache.length <= 0) return;
+
+    const byteLength = cache.reduce((p, data) => p + data.byteLength, 0);
+    const data = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const p of cache) {
+      data.set(p, offset);
+      offset += p.length;
+    }
+    await w.write(data);
+    this.bytesWritten.set(serial, (this.bytesWritten.get(serial) ?? 0) + data.length);
+    this.writerCache.delete(serial);
+  }
+
+  private async ensureWriter(serial: number): Promise<void> {
+    // Fast path if already created
+    if (this.writers.has(serial) || this.mbSampleSources.has(serial)) return;
+
+    const fname = this.onFileName?.(serial) ?? `track-${serial}.${this.format}`;
+    const fileHandle = await this.directoryHandle.getFileHandle(fname, { create: true });
+
+    if (this.format === 'ogg') {
+      const ws = await fileHandle.createWritable();
+      this.writers.set(serial, ws);
+      if (!this.lastSequenceNo.has(serial)) this.lastSequenceNo.set(serial, 0);
+    } else {
+      const output = new Output({
+        format:
+          this.format === 'aac' ? new AdtsOutputFormat() : this.format === 'flac' ? new FlacOutputFormat() : new WavOutputFormat({ large: true }),
+        target: await this.fileHandleToStreamTarget(fileHandle, (pos, len) =>
+          this.bytesWritten.set(serial, Math.max(this.bytesWritten.get(serial) ?? 0, pos + len))
+        )
+      });
+      const audioSource = new AudioSampleSource({
+        codec: this.format === 'wav' ? 'pcm-f32' : this.format,
+        bitrate: QUALITY_HIGH
+      });
+      output.addAudioTrack(audioSource);
+      this.mbOutputs.set(serial, output);
+      this.mbSampleSources.set(serial, audioSource);
+      await output.start();
+    }
+  }
+
+  private onWorkerMessage(msg: WorkerMessage): void {
+    if (this.aborted) return;
+
+    if (msg.type === 'page') {
+      const pageBuf = new Uint8Array(msg.page);
+      const meta: PageMeta = msg.meta;
+      this.outstandingNetworkBytes = Math.max(0, this.outstandingNetworkBytes - meta.payloadLength);
+
+      const serial = meta.serial;
+
+      // Skip excluded tracks entirely
+      if (this.isTrackExcluded(serial)) {
+        this.checkResume();
+        return;
+      }
+
+      const pageSegments = pageBuf[26]!;
+      const headerTotalLen = 27 + pageSegments;
+      // Copy payload to avoid issues with transferred buffer
+      const payload = pageBuf.slice(headerTotalLen);
+      const granulePosition = BigInt(meta.granulePosition);
+
+      // Determine stream type if header
+      if (granulePosition === 0n) {
+        if (payload.length < 5) return;
+        if (bytesEqual(payload.subarray(0, 4), OPUS)) {
+          this.streamTypes.set(serial, 'opus');
+          this.onTrackDiscovered?.(serial, 'opus');
+
+          if (this.format === 'ogg') {
+            if (bytesEqual(payload.subarray(0, 8), OPUS_TAGS) && opusTagsAreIncorrect(payload)) {
+              // Fix opus tags
+              this.writePage(
+                serial,
+                createPage({
+                  version: 0,
+                  headerType: meta.headerType,
+                  granulePosition: 0n,
+                  bitstreamSerialNumber: serial,
+                  pageSequenceNumber: meta.pageSequenceNumber,
+                  payload: concatUint8Arrays(payload, new Uint8Array([0, 0, 0, 0]))
+                })
+              );
+            } else {
+              // Rewrite page due to potential CRC mismatches
+              this.writePage(
+                serial,
+                createPage({
+                  version: 0,
+                  headerType: meta.headerType,
+                  granulePosition: 0n,
+                  bitstreamSerialNumber: serial,
+                  pageSequenceNumber: meta.pageSequenceNumber,
+                  payload
+                })
+              );
+            }
+            this.lastSequenceNo.set(serial, meta.pageSequenceNumber);
+          }
+        } else if (bytesEqual(payload.subarray(0, 5), FLAC)) {
+          this.streamTypes.set(serial, 'flac');
+          this.onTrackDiscovered?.(serial, 'flac');
+
+          if (payload.length > 29) {
+            const flacRate = (payload[27]! << 12) + (payload[28]! << 4) + (payload[29]! >> 4);
+            this.streamFlacRates.set(serial, flacRate);
+          }
+          if (this.format === 'ogg') {
+            // Copy the entire page since pageBuf references transferred buffer
+            this.writePage(serial, pageBuf.slice());
+            this.lastSequenceNo.set(serial, meta.pageSequenceNumber);
+          }
+        }
+        return;
+      }
+
+      if (!this.granuleOffset) this.granuleOffset = granulePosition;
+      if (payload.length <= 1) return;
+
+      const type = this.streamTypes.get(serial);
+      if (!type) return;
+
+      const frameCount = type === 'opus' ? getFramesInPacket(payload) : 1;
+      const frameSize = type === 'opus' ? getFrameSize(payload) : 960;
+      const packetSamples = BigInt(frameCount * frameSize);
+
+      const flacRate = this.streamFlacRates.get(serial) ?? 48000;
+      const convert = (p: bigint) => (flacRate === 44100 ? ((p - this.granuleOffset!) * 147n) / 160n : p - this.granuleOffset!);
+
+      let currentPosition = this.positions.get(serial) ?? this.granuleOffset;
+
+      // Packet far behind: drop
+      if (currentPosition > granulePosition + BigInt(frameSize * 25)) return;
+
+      // Packet far ahead: insert silence
+      if (currentPosition + DEFAULT_PACKET_TIME * 25n < granulePosition) {
+        const gap = granulePosition - currentPosition;
+        const framesToInsert = Number(gap) / Number(DEFAULT_PACKET_TIME);
+
+        for (let i = 0; i < Math.round(framesToInsert); i++) {
+          const payloadSilent = type === 'opus' ? SILENT_OPUS : flacRate === 44100 ? SILENT_FLAC_44K : SILENT_FLAC_48K;
+          const outPage = createPage({
+            version: 0,
+            headerType: 0,
+            granulePosition: convert(currentPosition),
+            bitstreamSerialNumber: serial,
+            pageSequenceNumber: this.getNextSequenceNumber(serial),
+            payload: payloadSilent
+          });
+          if (this.format === 'ogg') {
+            this.writePage(serial, outPage);
+          } else {
+            this.writePacket(serial, convert(currentPosition));
+          }
+          currentPosition += DEFAULT_PACKET_TIME;
+        }
+
+        // Append the real packet after silence
+        const dataOut = createPage({
+          version: 0,
+          headerType: 0,
+          granulePosition: convert(currentPosition),
+          bitstreamSerialNumber: serial,
+          pageSequenceNumber: this.getNextSequenceNumber(serial),
+          payload
+        });
+        if (this.format === 'ogg') this.writePage(serial, dataOut);
+        else this.writePacket(serial, convert(currentPosition), payload);
+        currentPosition += packetSamples;
+        this.positions.set(serial, currentPosition);
+      } else {
+        // Normal append
+        const outPage = createPage({
+          version: 0,
+          headerType: 0,
+          granulePosition: convert(currentPosition),
+          bitstreamSerialNumber: serial,
+          pageSequenceNumber: this.getNextSequenceNumber(serial),
+          payload
+        });
+        if (this.format === 'ogg') this.writePage(serial, outPage);
+        else this.writePacket(serial, convert(currentPosition), payload);
+        this.positions.set(serial, currentPosition + packetSamples);
+      }
+
+      // Check backpressure
+      const totalQueued = this.totalQueuedBytes();
+      if (this.readerPaused && totalQueued <= LOW_WATERMARK) {
+        this.readerPaused = false;
+        if (this.readerPausedResolve) {
+          this.readerPausedResolve();
+          this.readerPausedResolve = null;
+        }
+      }
+    } else if (msg.type === 'consumed') {
+      this.outstandingNetworkBytes = Math.max(0, this.outstandingNetworkBytes - (msg.consumed ?? 0));
+      this.checkResume();
+    } else if (msg.type === 'error') console.error('Worker error', msg.message);
+    else if (msg.type === 'done') this._workerDone?.();
+  }
+
+  async start(): Promise<void> {
+    if (this.format !== 'ogg') {
+      this.opusDecoder = new OpusDecoderWebWorker({ forceStereo: true, sampleRate: 48_000 });
+      this.flacDecoder = new FLACDecoderWebWorker();
+      await Promise.all([this.opusDecoder.ready, this.flacDecoder.ready]);
+
+      if (!this.silentAudioBuffer) {
+        this.silentAudioBuffer = (await this.opusDecoder.decodeFrame(SILENT_OPUS)).channelData;
+      }
+      if (!this.silentAudioBuffer44k) {
+        this.silentAudioBuffer44k = (await this.flacDecoder.decode(SILENT_FLAC_44K)).channelData;
+      }
+
+      const canDo = await canEncodeAudio(this.format === 'wav' ? 'pcm-f32' : this.format, {
+        numberOfChannels: 2,
+        sampleRate: 48_000
+      });
+      if (!canDo) throw new Error(`Browser cannot encode ${this.format} audio`);
+    }
+
+    const worker = new Worker(new URL('./oggParser.worker.ts', import.meta.url), {
+      type: 'module',
+      name: 'ogg-parser'
+    });
+    const waitForWorker = new Promise<void>((resolve) => (this._workerDone = resolve));
+    worker.addEventListener('message', (ev: MessageEvent) => this.onWorkerMessage(ev.data));
+
+    try {
+      try {
+        while (!this.aborted) {
+          const { done, value } = await this.reader.read();
+          if (done) {
+            worker.postMessage({ type: 'end' });
+            break;
+          }
+          if (!value) continue;
+
+          this.outstandingNetworkBytes += value.byteLength;
+          this.downloadedBytes += value.byteLength;
+          worker.postMessage({ type: 'chunk', chunk: value.buffer }, [value.buffer]);
+          this.onProgress?.();
+
+          // Backpressure
+          const totalQueued = this.totalQueuedBytes();
+          if (totalQueued > HIGH_WATERMARK) {
+            this.readerPaused = true;
+            await new Promise<void>((resolve) => (this.readerPausedResolve = resolve));
+          }
+        }
+      } finally {
+        try {
+          this.reader.releaseLock();
+        } catch {}
+      }
+
+      if (!this.aborted) await waitForWorker;
+      worker.terminate();
+
+      console.debug(`[Minizel] Worker done. Streams discovered: ${this.streamTypes.size}, Downloaded: ${this.downloadedBytes} bytes`);
+
+      if (this.format === 'ogg')
+        await Promise.all(
+          Array.from(this.writers.entries()).map(async ([serial, w]) => {
+            await this.queues.get(serial)?.done();
+            await this.flushWriterCache(serial);
+            await w.close();
+          })
+        );
+      else
+        await Promise.all(
+          Array.from(this.mbSampleSources.entries()).map(async ([serial]) => {
+            await this.queues.get(serial)?.done();
+            await this.mbOutputs.get(serial)!.finalize();
+          })
+        );
+
+      console.debug(`[Minizel] Finalized. Tracks: ${this.streamTypes.size}, Total bytes written: ${Array.from(this.bytesWritten.values()).reduce((a, b) => a + b, 0)}`);
+
+      // Check for empty output
+      const totalWritten = Array.from(this.bytesWritten.values()).reduce((a, b) => a + b, 0);
+      if (totalWritten === 0 && this.streamTypes.size === 0) {
+        throw new Error('No audio tracks were found in the recording');
+      }
+    } catch (e) {
+      console.error('Processor error!', e);
+      worker.terminate();
+      await Promise.all(
+        Array.from(this.queues.entries()).map(async ([serial, q]) => {
+          q.clear();
+          await this.mbOutputs.get(serial)?.cancel();
+          this.mbSampleSources.get(serial)?.close();
+        })
+      );
+      throw e;
+    } finally {
+      await this.opusDecoder?.free();
+      this.opusDecoder = null;
+      await this.flacDecoder?.free();
+      this.flacDecoder = null;
+    }
+  }
+}
diff --git a/apps/ferret/src/lib/minizel/resilientFetch.ts b/apps/ferret/src/lib/minizel/resilientFetch.ts
new file mode 100644
index 00000000..f2a159e4
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/resilientFetch.ts
@@ -0,0 +1,163 @@
+/**
+ * Resilient fetch for streaming large files with automatic retry/resume on connection drops.
+ * Uses HTTP Range requests to resume from where the connection was lost.
+ */
+
+export interface ResilientFetchOptions {
+  /** Maximum number of retry attempts (default: 10) */
+  maxRetries?: number;
+  /** Base delay between retries in ms (default: 1000) */
+  retryDelay?: number;
+  /** Abort signal to cancel the entire operation */
+  signal?: AbortSignal;
+  /** Callback when a retry occurs */
+  onRetry?: (attempt: number, bytesReceived: number) => void;
+  /** Callback when total size is known (from Content-Length or Content-Range) */
+  onTotalSize?: (totalSize: number) => void;
+}
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+/**
+ * Creates a ReadableStream that automatically retries/resumes on connection errors.
+ * The server must support HTTP Range requests (Accept-Ranges: bytes).
+ */
+export function createResilientStream(url: string, options: ResilientFetchOptions = {}): ReadableStream<Uint8Array> {
+  const { maxRetries = 10, retryDelay = 1000, signal, onRetry, onTotalSize } = options;
+
+  let bytesReceived = 0;
+  let totalSize: number | null = null;
+  let totalSizeReported = false;
+  let currentReader: ReadableStreamDefaultReader<Uint8Array> | null = null;
+  let retryCount = 0;
+  let aborted = false;
+
+  signal?.addEventListener('abort', () => {
+    aborted = true;
+    currentReader?.cancel().catch(() => {});
+  });
+
+  async function tryConnect(): Promise<boolean> {
+    try {
+      const headers: HeadersInit = {};
+      if (bytesReceived > 0) headers['Range'] = `bytes=${bytesReceived}-`;
+
+      const response = await fetch(url, { headers, signal });
+
+      if (!response.ok && response.status !== 206) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+
+      // Get total size from first response
+      if (totalSize === null) {
+        const contentRange = response.headers.get('Content-Range');
+        if (contentRange) {
+          const match = contentRange.match(/\/(\d+)$/);
+          if (match) totalSize = parseInt(match[1], 10);
+        } else {
+          const contentLength = response.headers.get('Content-Length');
+          if (contentLength) totalSize = parseInt(contentLength, 10);
+        }
+
+        // Report total size once
+        if (totalSize !== null && !totalSizeReported) {
+          totalSizeReported = true;
+          onTotalSize?.(totalSize);
+        }
+      }
+
+      if (!response.body) throw new Error('Response has no body');
+
+      currentReader = response.body.getReader();
+      retryCount = 0; // Reset retry count on successful connection
+      return true;
+    } catch (err) {
+      if (aborted || signal?.aborted) return false;
+
+      retryCount++;
+      if (retryCount > maxRetries) throw new Error(`Failed after ${maxRetries} retries: ${err}`);
+
+      onRetry?.(retryCount, bytesReceived);
+
+      // Exponential backoff with jitter
+      const delay = retryDelay * Math.pow(1.5, retryCount - 1) + Math.random() * 500;
+      await sleep(delay);
+      return false;
+    }
+  }
+
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      // Main pull loop - keeps trying until we get data, complete, or exhaust retries
+      while (true) {
+        if (aborted || signal?.aborted) {
+          controller.close();
+          return;
+        }
+
+        // Connect if needed
+        if (!currentReader) {
+          try {
+            const connected = await tryConnect();
+            if (!connected) continue; // Retry connection
+          } catch (err) {
+            controller.error(err);
+            return;
+          }
+        }
+
+        // Read from current connection
+        try {
+          const { done, value } = await currentReader!.read();
+
+          if (done) {
+            // Check if we got all the data
+            if (totalSize !== null && bytesReceived < totalSize) {
+              // Connection closed prematurely, retry
+              currentReader = null;
+              retryCount++;
+              if (retryCount <= maxRetries) {
+                onRetry?.(retryCount, bytesReceived);
+                const delay = retryDelay * Math.pow(1.5, retryCount - 1) + Math.random() * 500;
+                await sleep(delay);
+                continue; // Retry in the loop
+              }
+            }
+            controller.close();
+            return;
+          }
+
+          if (value) {
+            bytesReceived += value.byteLength;
+            controller.enqueue(value);
+            return; // Successfully delivered a chunk
+          }
+        } catch (err) {
+          if (aborted || signal?.aborted) {
+            controller.close();
+            return;
+          }
+
+          // Connection error, try to resume
+          currentReader = null;
+          retryCount++;
+
+          if (retryCount <= maxRetries) {
+            onRetry?.(retryCount, bytesReceived);
+            const delay = retryDelay * Math.pow(1.5, retryCount - 1) + Math.random() * 500;
+            await sleep(delay);
+            continue; // Retry in the loop
+          }
+
+          controller.error(new Error(`Connection lost after ${bytesReceived} bytes, retries exhausted: ${err}`));
+          return;
+        }
+      }
+    },
+
+    cancel() {
+      aborted = true;
+      currentReader?.cancel().catch(() => {});
+    }
+  });
+}
diff --git a/apps/ferret/src/lib/minizel/util.ts b/apps/ferret/src/lib/minizel/util.ts
new file mode 100644
index 00000000..883d641d
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/util.ts
@@ -0,0 +1,97 @@
+/** Silent OPUS frame (3 bytes) */
+export const SILENT_OPUS = new Uint8Array([0xf8, 0xff, 0xfe]);
+
+/** Default packet time in samples (20ms at 48kHz) */
+export const DEFAULT_PACKET_TIME = 960n;
+
+/** Silent FLAC frame at 48kHz */
+export const SILENT_FLAC_48K = new Uint8Array([0xff, 0xf8, 0x7a, 0x0c, 0x00, 0x03, 0xbf, 0x94, 0x00, 0x00, 0x00, 0x00, 0xb1, 0xca]);
+
+/** Silent FLAC frame at 44.1kHz */
+export const SILENT_FLAC_44K = new Uint8Array([0xff, 0xf8, 0x79, 0x0c, 0x00, 0x03, 0x71, 0x56, 0x00, 0x00, 0x00, 0x00, 0x63, 0xc5]);
+
+/** OPUS header magic bytes */
+export const OPUS = new TextEncoder().encode('Opus');
+
+/** FLAC header magic bytes */
+export const FLAC = new TextEncoder().encode('\x7fFLAC');
+
+/** OPUS tags header magic bytes */
+export const OPUS_TAGS = new TextEncoder().encode('OpusTags');
+
+/** Memory management constants - conservative for broader device support */
+export const HIGH_WATERMARK = 30 * 1024 * 1024; // 30 MB
+export const LOW_WATERMARK = 15 * 1024 * 1024; // 15 MB
+
+/** Chunk size for file writes */
+export const CHUNK_SIZE = 256 * 1024; // 256 KB
+
+/** Max samples in-flight per track to prevent memory buildup */
+export const MAX_PENDING_SAMPLES = 50;
+
+/** Max seconds to buffer for mixing */
+export const MIX_BUFFER_SECONDS = 3;
+
+/** Standard sample rate */
+export const SAMPLE_RATE = 48_000;
+
+/** Mix step size in samples */
+export const MIX_STEP = 960;
+
+/**
+ * Check if opus tags are missing the user comment list length
+ * https://datatracker.ietf.org/doc/html/rfc7845#section-5.2
+ */
+export function opusTagsAreIncorrect(tags: Uint8Array): boolean {
+  const view = new DataView(tags.buffer, tags.byteOffset, tags.byteLength);
+  const vendorLength = view.getUint32(8, true);
+  return tags.length <= 12 + vendorLength;
+}
+
+/** Compare two Uint8Arrays for equality */
+export function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a === b) return true;
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+/** Concatenate two Uint8Arrays */
+export function concatUint8Arrays(a: Uint8Array, b: Uint8Array): Uint8Array {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
+}
+
+/** Format bytes as human readable string */
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const formattedSize = (bytes / Math.pow(k, i)).toFixed(2);
+  return `${formattedSize} ${units[i]}`;
+}
+
+/** Convert seconds to time mark string (HH:MM:SS.ss) */
+export function convertToTimeMark(seconds: number, includeHours?: boolean): string {
+  if (isNaN(seconds) || seconds < 0) return '00:00';
+
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const remainingSeconds = Math.floor(seconds % 60);
+
+  const formattedHours = hours.toString().padStart(2, '0');
+  const formattedMinutes = minutes.toString().padStart(2, '0');
+  const formattedSeconds = remainingSeconds.toString().padStart(2, '0');
+
+  if (hours === 0 && !includeHours) {
+    return `${formattedMinutes}:${formattedSeconds}`;
+  }
+  return `${formattedHours}:${formattedMinutes}:${formattedSeconds}`;
+}
+
+export type MinizelFormat = 'ogg' | 'aac' | 'flac' | 'wav';
diff --git a/apps/ferret/src/lib/recording/sections.ts b/apps/ferret/src/lib/recording/sections.ts
index 4e40e1df..af704ed3 100644
--- a/apps/ferret/src/lib/recording/sections.ts
+++ b/apps/ferret/src/lib/recording/sections.ts
@@ -9,17 +9,25 @@ import mp3Icon from '@iconify-icons/mdi/emoticon-frown';
 import fileIcon from '@iconify-icons/mdi/file';
 import textFileIcon from '@iconify-icons/mdi/file-text';
 
-import type { DevicePlatform } from '$lib/device';
+import type { DeviceCapability, DevicePlatform } from '$lib/device';
+import type { MinizelFormat } from '$lib/minizel';
 import type { MinimalRecordingInfo } from '$lib/types';
 import type { Translatable } from '$lib/util';
 
 export type SectionButtons = {
   title: Translatable;
+  beta?: boolean;
   features?: MinimalRecordingInfo['features'];
   showFor?: DevicePlatform[];
+  capabilities?: DeviceCapability[];
   buttons: SectionButton[];
 }[];
 
+export type MinizelOptions = {
+  format: MinizelFormat;
+  mix?: boolean;
+};
+
 export type SectionButton = {
   text: Translatable;
   suffix?: string;
@@ -30,6 +38,7 @@ export type SectionButton = {
     container?: Kitchen.ContainerType;
   };
   ennuizel?: number;
+  minizel?: MinizelOptions;
   allowNorm?: boolean;
   noIgnore?: boolean;
   showFor?: DevicePlatform[];
@@ -58,7 +67,7 @@ export const audioButtons: SectionButtons = [
         allowNorm: true
       },
       { text: 'FLAC', options: { format: 'flac' }, allowNorm: true },
-      { text: 'wav', ennuizel: 5 },
+      { text: 'WAV', ennuizel: 5 },
       { text: 'AAC', suffix: '(MPEG-4)', options: { format: 'aac' }, allowNorm: true },
       { text: 'ALAC', suffix: '(Apple Lossless)', ennuizel: 6, showFor: ['mac'], allowNorm: true },
       { text: 'Ogg Vorbis', options: { format: 'vorbis' }, allowNorm: true },
@@ -76,7 +85,7 @@ export const audioButtons: SectionButtons = [
     title: { t: 'download.sections.st' },
     buttons: [
       { text: 'FLAC', ennuizel: 0x30 },
-      { text: 'wav', ennuizel: 0x35 },
+      { text: 'WAV', ennuizel: 0x35 },
       { text: 'AAC', suffix: '(MPEG-4)', ennuizel: 0x31 },
       { text: { t: 'download.format_buttons.other' }, ennuizel: 0x230 }
     ]
@@ -91,6 +100,21 @@ export const audioButtons: SectionButtons = [
       { icon: mp3Icon, text: 'MP3', options: { format: 'mp3', container: 'mix' }, features: ['mp3'] }
     ]
   },
+  {
+    title: { t: 'download.sections.minizel' },
+    beta: true,
+    capabilities: ['minizel'],
+    buttons: [
+      { text: 'FLAC', suffix: '(Multi-track)', minizel: { format: 'flac' }, noIgnore: true },
+      { text: 'AAC', suffix: '(Multi-track)', minizel: { format: 'aac' }, noIgnore: true },
+      { text: 'WAV', suffix: '(Multi-track)', minizel: { format: 'wav' }, noIgnore: true },
+      { text: 'Ogg', suffix: '(Multi-track)', minizel: { format: 'ogg' }, noIgnore: true },
+
+      { text: 'FLAC', suffix: '(Mixed)', minizel: { format: 'flac', mix: true }, noIgnore: true },
+      { text: 'AAC', suffix: '(Mixed)', minizel: { format: 'aac', mix: true }, noIgnore: true },
+      { text: 'WAV', suffix: '(Mixed)', minizel: { format: 'wav', mix: true }, noIgnore: true }
+    ]
+  },
   {
     title: { t: 'download.sections.local_processing' },
     showFor: ['desktop'],
diff --git a/apps/ferret/src/lib/server/util.ts b/apps/ferret/src/lib/server/util.ts
index d18db82b..fda9e79a 100644
--- a/apps/ferret/src/lib/server/util.ts
+++ b/apps/ferret/src/lib/server/util.ts
@@ -219,6 +219,8 @@ export function errorResponse(code?: APIErrorCode, init?: ResponseInit, extra?:
       return result('Server error');
     case APIErrorCode.INVALID_BODY:
       return result('Invalid body');
+    case APIErrorCode.INVALID_RANGE:
+      return result('Range not satisfiable');
     case APIErrorCode.KEY_REQUIRED:
       return result('Key required');
     case APIErrorCode.INVALID_RECORDING:
diff --git a/apps/ferret/src/lib/types.ts b/apps/ferret/src/lib/types.ts
index b5f2934a..4d88bf28 100644
--- a/apps/ferret/src/lib/types.ts
+++ b/apps/ferret/src/lib/types.ts
@@ -10,6 +10,7 @@ export enum APIErrorCode {
   UNKNOWN_ERROR = 'unknown',
   SERVER_ERROR = 'server_error',
   INVALID_BODY = 'invalid_body',
+  INVALID_RANGE = 'invalid_range',
 
   KEY_REQUIRED = 'no_key',
   INVALID_RECORDING = 'invalid_rec',
diff --git a/apps/ferret/src/routes/+layout.ts b/apps/ferret/src/routes/+layout.ts
index 5a4a6b40..ce3c826d 100644
--- a/apps/ferret/src/routes/+layout.ts
+++ b/apps/ferret/src/routes/+layout.ts
@@ -4,8 +4,9 @@ import type { Load } from '@sveltejs/kit';
 import { dictionary, locale, waitLocale } from 'svelte-i18n';
 
 import { browser } from '$app/environment';
-import { get, localeCookieName } from '$lib/cookie';
+import { get as getCookie, localeCookieName } from '$lib/cookie';
 import { device } from '$lib/device';
+import { get } from 'svelte/store';
 
 // svelte-i18n doesn't exactly wait for keys to be populated before finishing up, so this waits for that.
 function waitForLocaleUpdate() {
@@ -37,7 +38,7 @@ function waitForLocaleUpdate() {
 
 export const load: Load = async () => {
   if (browser) {
-    locale.set(get(localeCookieName) || device.prefers.language);
+    locale.set(getCookie(localeCookieName) || get(device)?.prefers?.language || 'en');
     window.plausible = window.plausible || ((e, o, ev) => (window.plausible.q = window.plausible.q || []).push([e, o, ev]));
     console.time('Locale Loaded');
   }
diff --git a/apps/ferret/src/routes/api/v1/recordings/[id=recording]/raw.dat/+server.ts b/apps/ferret/src/routes/api/v1/recordings/[id=recording]/raw.dat/+server.ts
index 523afc87..ceb02d12 100644
--- a/apps/ferret/src/routes/api/v1/recordings/[id=recording]/raw.dat/+server.ts
+++ b/apps/ferret/src/routes/api/v1/recordings/[id=recording]/raw.dat/+server.ts
@@ -1,6 +1,6 @@
-import { createReadStream } from 'fs';
-import { stat } from 'fs/promises';
+import { open, stat } from 'fs/promises';
 import { join } from 'path';
+import { Readable } from 'stream';
 
 import { REC_DIRECTORY } from '$lib/server/config';
 import { errorResponse, getRecordingInfo, recordingExists } from '$lib/server/util';
@@ -24,58 +24,111 @@ export const GET: RequestHandler = async ({ url, params, request }) => {
   const recFileBase = join(REC_DIRECTORY, `${id}.ogg`);
   const files = [`${recFileBase}.header1`, `${recFileBase}.header2`, `${recFileBase}.data`];
 
-  const sizes = await Promise.all(files.map((file) => stat(file)));
-  const totalSize = sizes.reduce((total, stats) => total + stats.size, 0);
+  // Check all files exist and get sizes
+  const sizes = await Promise.all(files.map((file) => stat(file).catch(() => null)));
+  if (sizes.some((s) => s === null)) return errorResponse(APIErrorCode.RECORDING_NO_DATA, { status: 404 });
+  const fileSizes = sizes.map((s) => s!.size);
+  const totalSize = fileSizes.reduce((total, size) => total + size, 0);
 
-  const abortController = new AbortController();
-  const readableStream = new ReadableStream({
-    async start(controller) {
-      const openStreams = [];
+  // Parse Range header for resume support
+  const rangeHeader = request.headers.get('Range');
+  let rangeStart = 0;
+  let rangeEnd = totalSize - 1;
+  let isPartial = false;
+
+  if (rangeHeader) {
+    const match = rangeHeader.match(/bytes=(\d+)-(\d*)/);
+    if (match) {
+      rangeStart = parseInt(match[1], 10);
+      if (match[2]) rangeEnd = parseInt(match[2], 10);
+      if (rangeStart >= 0 && rangeStart < totalSize) {
+        isPartial = true;
+        rangeEnd = Math.min(rangeEnd, totalSize - 1);
+      } else
+        return errorResponse(APIErrorCode.INVALID_RANGE, {
+          status: 416,
+          headers: { 'Content-Range': `bytes */${totalSize}` }
+        });
+    }
+  }
+
+  const contentLength = rangeEnd - rangeStart + 1;
+
+  // Create a combined Node.js readable stream from all files with range support
+  async function* generateChunks(): AsyncGenerator<Buffer> {
+    let globalOffset = 0;
+    let bytesToSkip = rangeStart;
+    let bytesRemaining = contentLength;
+
+    for (let i = 0; i < files.length && bytesRemaining > 0; i++) {
+      const file = files[i];
+      const fileSize = fileSizes[i];
+
+      // Skip entire file if range starts after it
+      if (bytesToSkip >= fileSize) {
+        bytesToSkip -= fileSize;
+        globalOffset += fileSize;
+        continue;
+      }
+
+      if (request.signal.aborted) return;
+
+      const handle = await open(file, 'r');
       try {
-        for (const file of files) {
-          if (request.signal.aborted || abortController.signal.aborted) break;
-          const stream = createReadStream(file);
-          openStreams.push(stream);
-
-          for await (const chunk of stream) {
-            if (request.signal.aborted || abortController.signal.aborted) {
-              for (const s of openStreams) {
-                try {
-                  s.destroy();
-                } catch {}
-              }
-              controller.close();
-              return;
-            }
-            controller.enqueue(new Uint8Array(chunk));
+        const startInFile = bytesToSkip;
+        bytesToSkip = 0;
+
+        const stream = handle.createReadStream({
+          start: startInFile,
+          highWaterMark: 256 * 1024
+        });
+
+        for await (const chunk of stream) {
+          if (request.signal.aborted) {
+            stream.destroy();
+            return;
           }
-          stream.close();
 
-          openStreams.pop();
-        }
+          let data: Buffer = chunk;
+          if (data.length > bytesRemaining) data = data.subarray(0, bytesRemaining);
+
+          bytesRemaining -= data.length;
+          yield data;
 
-        controller.close();
-      } catch (err) {
-        for (const s of openStreams)
-          try {
-            s.destroy();
-          } catch {}
-        controller.error(err instanceof Error ? err : new Error(String(err)));
+          if (bytesRemaining <= 0) {
+            stream.destroy();
+            break;
+          }
+        }
+      } finally {
+        await handle.close().catch(() => {});
       }
-    },
-    cancel() {
-      abortController.abort();
-    }
-  });
 
-  const response = new Response(readableStream, {
-    headers: {
-      'Content-Type': 'application/octet-stream',
-      'Cache-Control': 'max-age=120',
-      'Content-Disposition': `attachment; filename="craig-${id}-raw.dat"`,
-      'Content-Length': totalSize.toString()
+      globalOffset += fileSize;
     }
+  }
+
+  const nodeStream = Readable.from(generateChunks(), { highWaterMark: 256 * 1024 });
+  const webStream = Readable.toWeb(nodeStream) as ReadableStream<Uint8Array>;
+
+  request.signal.addEventListener('abort', () => {
+    nodeStream.destroy();
   });
 
-  return response;
+  const headers: HeadersInit = {
+    'Content-Type': 'application/octet-stream',
+    'Cache-Control': 'no-cache, no-store, must-revalidate',
+    'Content-Disposition': `attachment; filename="craig-${id}-raw.dat"`,
+    'Content-Length': contentLength.toString(),
+    'X-Content-Type-Options': 'nosniff',
+    'Accept-Ranges': 'bytes',
+    'X-Accel-Buffering': 'no'
+  };
+
+  if (isPartial) {
+    headers['Content-Range'] = `bytes ${rangeStart}-${rangeEnd}/${totalSize}`;
+    return new Response(webStream, { status: 206, headers });
+  }
+
+  return new Response(webStream, { headers });
 };
diff --git a/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte b/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
index 130399dc..50f869d6 100644
--- a/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
+++ b/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
@@ -3,13 +3,15 @@
   import alertIcon from '@iconify-icons/mdi/alert-circle';
   import lockIcon from '@iconify-icons/mdi/lock';
   import warnIcon from '@iconify-icons/mdi/warning';
+  import { onMount } from 'svelte';
   import { fade, fly } from 'svelte/transition';
   import { t } from 'svelte-i18n';
   import Portal from 'svelte-portal';
 
   import FormatButton from '$components/FormatButton.svelte';
   import RequiresTier from '$components/RequiresTier.svelte';
-  import { device } from '$lib/device';
+  import { device, refreshDeviceCapabilities } from '$lib/device';
+  import type { MinizelFormat } from '$lib/minizel';
   import { jobOpen } from '$lib/recording/data';
   import { audioButtons, type FocusedButton, type SectionButton, transcriptionButtons } from '$lib/recording/sections';
   import type { MinimalRecordingInfo, RecordingPageEmitter } from '$lib/types';
@@ -18,6 +20,7 @@
   import AvatarOverlaysButton from './AvatarOverlaysButton.svelte';
   import DownloadAvatarsButton from './DownloadAvatarsButton.svelte';
   import DownloadModal from './DownloadModal.svelte';
+  import MinizelModal from './MinizelModal.svelte';
   import WhichDoIUse from './WhichDoIUse.svelte';
 
   interface Props {
@@ -37,12 +40,25 @@
   let showWDIU = $state(false);
 
   let focusedButton: FocusedButton | null = $state(null);
+  let minizelModal: { format: MinizelFormat; mix: boolean } | null = $state(null);
+  let minizelProcessing = $state(false);
+
   function onModalClick(this: any, e: any) {
     if (e.target === this) {
       focusedButton = null;
       showWDIU = false;
+      if (!minizelProcessing) minizelModal = null;
     }
   }
+
+  function isMinizelButtonAvailable(button: SectionButton) {
+    if (!button.minizel) return false;
+    if (!$device.capabilities.minizel) return false;
+    if (button.minizel.mix) return $device.capabilities.showSaveFilePicker;
+    return $device.capabilities.showDirectoryPicker;
+  }
+
+  onMount(() => refreshDeviceCapabilities());
 </script>
 
 {#if noUsers}
@@ -82,20 +98,37 @@
       {#each audioButtons as section}
         {@const sectionAvailable =
           (!section.features || !section.features.map((f) => features.includes(f)).includes(false)) &&
-          (!section.showFor || audioShowHidden || section.showFor.map((f) => device.platform[f]).includes(true))}
-        {#if sectionAvailable}
+          (!section.showFor || audioShowHidden || section.showFor.map((f) => $device.platform[f]).includes(true)) &&
+          (!section.capabilities || section.capabilities.map((f) => $device.capabilities[f]).includes(true))}
+        {@const sectionHasMinizel = section.buttons.some((b) => b.minizel)}
+        {@const minizelSectionAvailable = sectionHasMinizel && $device.capabilities.minizel}
+        {#if sectionAvailable || minizelSectionAvailable}
           <div class="inline-flex flex-col items-start justify-start gap-2">
-            <div class="text-base font-medium text-neutral-400">{convertT(section.title, $t)}</div>
+            <div class="text-base font-medium text-neutral-400">
+              {convertT(section.title, $t)}
+              {#if section.beta}
+                <span class="rounded-full bg-purple-400 px-2 py-1 text-xs font-bold uppercase text-black">{$t('common.beta')}</span>
+              {/if}
+            </div>
             <div class="inline-flex flex-wrap items-start justify-start gap-3 self-stretch">
               {#each section.buttons as button}
                 {@const featureAvailable = !button.features || !button.features.map((f) => features.includes(f)).includes(false)}
-                {@const available = !button.showFor || button.showFor.map((f) => device.platform[f]).includes(true)}
-                {#if featureAvailable && (available || audioShowHidden)}
+                {@const available = !button.showFor || button.showFor.map((f) => $device.platform[f]).includes(true)}
+                {#if featureAvailable && (button.minizel ? isMinizelButtonAvailable(button) : true) && (available || audioShowHidden)}
                   <FormatButton
                     ennuizel={!!button.ennuizel}
+                    minizel={!!button.minizel}
                     suffix={button.suffix}
                     icon={button.icon}
-                    onclick={() => onButtonClick(button, section.title)}
+                    onclick={() => {
+                      if (button.minizel) {
+                        minizelModal = { format: button.minizel.format, mix: button.minizel.mix ?? false };
+                        window.plausible('minizel', {
+                          u: `${location.origin}/rec/:id`,
+                          props: { format: button.minizel.format, mix: button.minizel.mix ?? false }
+                        });
+                      } else onButtonClick(button, section.title);
+                    }}
                   >
                     {convertT(button.text, $t)}
                   </FormatButton>
@@ -116,7 +149,7 @@
         <div class="inline-flex flex-wrap items-start justify-start gap-3 self-stretch">
           {#each transcriptionButtons as button}
             {@const featureAvailable = !button.features || !button.features.map((f) => features.includes(f)).includes(false)}
-            {@const available = !button.showFor || button.showFor.map((f) => device.platform[f]).includes(true)}
+            {@const available = !button.showFor || button.showFor.map((f) => $device.platform[f]).includes(true)}
             {#if featureAvailable && (available || audioShowHidden)}
               <FormatButton
                 suffix={button.suffix}
@@ -193,3 +226,27 @@
     </div>
   </Portal>
 {/if}
+
+{#if minizelModal}
+  <Portal target="body">
+    <div
+      transition:fade={{ duration: 100 }}
+      class="fixed bottom-0 left-0 right-0 top-0 z-30 flex select-none items-end justify-center bg-black/40 backdrop-blur-sm md:items-center md:px-8"
+      aria-hidden="true"
+      onclick={onModalClick}
+    >
+      <div
+        transition:fly={{ duration: 250, y: 32 }}
+        class="relative inline-flex max-h-[calc(100svh-6rem)] w-[1024px] flex-col items-start justify-start overflow-hidden rounded-t-lg bg-zinc-900 text-neutral-300 shadow-lg ring-2 ring-purple-950/25 md:rounded-b-lg"
+      >
+        <div class="absolute left-0 right-0 top-0 z-0 h-40 max-h-[75%] bg-gradient-to-b from-purple-600 to-transparent opacity-25"></div>
+        <MinizelModal
+          format={minizelModal.format}
+          mix={minizelModal.mix}
+          onclose={() => (minizelModal = null)}
+          onprocessingchange={(v) => (minizelProcessing = v)}
+        />
+      </div>
+    </div>
+  </Portal>
+{/if}
diff --git a/apps/ferret/src/routes/rec/[id=recording]/MinizelModal.svelte b/apps/ferret/src/routes/rec/[id=recording]/MinizelModal.svelte
new file mode 100644
index 00000000..b133fbb5
--- /dev/null
+++ b/apps/ferret/src/routes/rec/[id=recording]/MinizelModal.svelte
@@ -0,0 +1,577 @@
+<script lang="ts">
+  import type { Recording } from '@craig/types';
+  import Icon from '@iconify/svelte';
+  import checkIcon from '@iconify-icons/mdi/check-circle';
+  import cogIcon from '@iconify-icons/mdi/cog';
+  import downloadIcon from '@iconify-icons/mdi/download';
+  import errorIcon from '@iconify-icons/mdi/error';
+  import { canEncodeAudio, registerEncoder } from 'mediabunny';
+  import { onDestroy, onMount } from 'svelte';
+  import { SvelteMap, SvelteSet } from 'svelte/reactivity';
+  import { t } from 'svelte-i18n';
+
+  import { page } from '$app/state';
+  import Button from '$components/Button.svelte';
+  import Checkbox from '$components/Checkbox.svelte';
+  import Modal from '$components/Modal.svelte';
+  import RecordingUserChip from '$components/RecordingUserChip.svelte';
+  import { loadingIcon } from '$lib/icons';
+  import {
+    convertToTimeMark,
+    createResilientStream,
+    formatBytes,
+    LibAVFlacEncoder,
+    type MinizelFormat,
+    MinizelProcessor,
+    MixedProcessor,
+    type TrackStats
+  } from '$lib/minizel';
+
+  const recording = page.data.recording!;
+  const users: Recording.RecordingUser[] = page.data.users!;
+  const key = page.data.key!;
+
+  interface Props {
+    format: MinizelFormat;
+    mix?: boolean;
+    onclose?: () => void;
+    onprocessingchange?: (isProcessing: boolean) => void;
+  }
+
+  let { format, mix = false, onclose, onprocessingchange }: Props = $props();
+
+  type ProcessState = 'idle' | 'selecting' | 'downloading' | 'processing' | 'complete' | 'error';
+
+  let processState = $state<ProcessState>('idle');
+  let errorMessage = $state('');
+  let processor: MinizelProcessor | MixedProcessor | null = $state(null);
+  let iconElem: HTMLLinkElement | undefined = $state();
+
+  // Stats
+  let elapsedMs = $state(0);
+  let startTime = $state(0);
+  let downloadedBytes = $state(0);
+  let totalBytes = $state(0);
+  let heldBytes = $state(0);
+  let bytesWritten = $state(0);
+  let trackStats: TrackStats[] = $state([]);
+  let mixPosition = $state(0);
+
+  // UI update throttling
+  const UI_UPDATE_INTERVAL_MS = 200;
+  const SPEED_SAMPLE_INTERVAL_MS = 1000;
+  let lastUIUpdateTime = $state(0);
+  let lastSpeedSampleTime = $state(0);
+  let currentDownloadSpeed = $state(0);
+  let currentWriteSpeed = $state(0);
+
+  // Track if we're in a state where modal shouldn't be closed
+  let isProcessing = $derived(processState === 'downloading' || processState === 'processing');
+
+  // Notify parent of processing state changes
+  $effect(() => {
+    onprocessingchange?.(isProcessing);
+  });
+
+  // Elapsed time ticker (updates every 500ms for display)
+  // Stops when processing completes or encounters an error
+  $effect(() => {
+    if (startTime !== 0 && processState !== 'complete' && processState !== 'error') {
+      const interval = setInterval(() => (elapsedMs = Math.max(0, performance.now() - startTime)), 500);
+      return () => clearInterval(interval);
+    } else if (startTime !== 0 && (processState === 'complete' || processState === 'error')) {
+      // Update one final time when process ends
+      elapsedMs = Math.max(0, performance.now() - startTime);
+    }
+  });
+
+  // Track exclusion - use SvelteSet for automatic reactivity
+  let excludedTracks = new SvelteSet<number>();
+
+  // Track serial -> user mapping - use SvelteMap for automatic reactivity
+  let trackUsers = new SvelteMap<number, Recording.RecordingUser>();
+
+  // Map track number -> stats for display
+  let trackStatsMap = $derived(new Map(trackStats.map((s) => [s.serial, s])));
+
+  // Download progress percentage
+  let downloadProgress = $derived(totalBytes > 0 ? Math.min(100, (downloadedBytes / totalBytes) * 100) : 0);
+
+  // Format speed as MB/s
+  function formatSpeed(bytesPerSec: number): string {
+    if (bytesPerSec >= 1024 * 1024) return `${(bytesPerSec / (1024 * 1024)).toFixed(2)} MB/s`;
+    else if (bytesPerSec >= 1024) return `${(bytesPerSec / 1024).toFixed(1)} KB/s`;
+    return `${bytesPerSec.toFixed(0)} B/s`;
+  }
+
+  function toggleTrackExclusion(trackNumber: number) {
+    if (excludedTracks.has(trackNumber)) excludedTracks.delete(trackNumber);
+    else excludedTracks.add(trackNumber);
+  }
+
+  function isAllExcluded(): boolean {
+    return users.length > 0 && excludedTracks.size === users.length;
+  }
+
+  function updateStats(force = false) {
+    const now = performance.now();
+    if (!processor) return;
+
+    // Throttle UI updates (unless forced)
+    if (!force && now - lastUIUpdateTime < UI_UPDATE_INTERVAL_MS) return;
+    lastUIUpdateTime = now;
+
+    const prevDownloaded = downloadedBytes;
+    const prevWritten = bytesWritten;
+    downloadedBytes = processor.downloadedBytes;
+
+    if (processor instanceof MinizelProcessor) {
+      heldBytes = processor.totalQueuedBytes();
+      trackStats = processor.getTrackStats();
+      bytesWritten = Array.from(processor.bytesWritten.values()).reduce((a, b) => a + b, 0);
+    } else {
+      heldBytes = processor.estimatedQueuedBytes();
+      bytesWritten = processor.bytesWritten;
+      mixPosition = processor.currentMixPosition;
+    }
+
+    // Calculate speed (less frequently than UI updates)
+    if (now - lastSpeedSampleTime >= SPEED_SAMPLE_INTERVAL_MS) {
+      const timeDelta = (now - lastSpeedSampleTime) / 1000;
+      currentDownloadSpeed = timeDelta > 0 ? (downloadedBytes - prevDownloaded) / timeDelta : 0;
+      currentWriteSpeed = timeDelta > 0 ? (bytesWritten - prevWritten) / timeDelta : 0;
+      lastSpeedSampleTime = now;
+    }
+
+    // Transition to processing state when download complete
+    if (processState === 'downloading' && totalBytes > 0 && downloadedBytes >= totalBytes) processState = 'processing';
+  }
+
+  function getFileName(serial: number): string {
+    const user = trackUsers.get(serial);
+    if (user)
+      return `${user.track}-${(user.discriminator === '0' ? user.username : `${user.username}#${user.discriminator}`).replace(/[^a-zA-Z0-9]/g, '_')}.${format}`;
+    return `${serial}-track.${format}`;
+  }
+
+  function onTrackDiscovered(serial: number, _type: 'opus' | 'flac') {
+    const user = users.find((u) => u.track === serial);
+    if (user) trackUsers.set(serial, user);
+  }
+
+  let flacPolyfillRegistered = false;
+  async function ensureFlacSupport() {
+    if (format !== 'flac' || flacPolyfillRegistered) return;
+
+    const canEncode = await canEncodeAudio('flac', {
+      numberOfChannels: 2,
+      sampleRate: 48000
+    });
+
+    if (!canEncode) {
+      console.log('Native FLAC encoding not supported, registering LibAV polyfill');
+      registerEncoder(LibAVFlacEncoder);
+      flacPolyfillRegistered = true;
+    }
+  }
+
+  async function startProcessing() {
+    await ensureFlacSupport();
+    processState = 'selecting';
+    errorMessage = '';
+
+    // Reset stats
+    lastUIUpdateTime = 0;
+    lastSpeedSampleTime = 0;
+    currentDownloadSpeed = 0;
+    currentWriteSpeed = 0;
+    downloadedBytes = 0;
+    bytesWritten = 0;
+    totalBytes = 0;
+
+    try {
+      // Show file/directory picker
+      let directoryHandle: FileSystemDirectoryHandle | null = null;
+      let fileHandle: FileSystemFileHandle | null = null;
+
+      if (mix) {
+        // Single file for mix
+        const ext = format === 'aac' ? 'aac' : format === 'flac' ? 'flac' : 'wav';
+        fileHandle = await window.showSaveFilePicker({
+          suggestedName: `craig-${recording.id}-mix.${ext}`,
+          types: [
+            {
+              description: `${format.toUpperCase()} Audio`,
+              // @ts-ignore
+              accept: { [`audio/${ext}`]: [`.${ext}`] }
+            }
+          ]
+        });
+      } else {
+        // Directory for multi-track
+        directoryHandle = await window.showDirectoryPicker({
+          mode: 'readwrite',
+          id: `minizel-${recording.id}`
+        });
+
+        // Check if directory is empty, if not create a subdirectory
+        const isEmpty = (await directoryHandle.keys().next()).done;
+        if (!isEmpty) {
+          directoryHandle = await directoryHandle.getDirectoryHandle(`craig-${recording.id}`, { create: true });
+        }
+      }
+
+      processState = 'downloading';
+      startTime = performance.now();
+
+      // Create resilient stream that auto-retries on connection drops
+      const abortController = new AbortController();
+      const rawStream = createResilientStream(`/api/v1/recordings/${recording.id}/raw.dat?key=${key}`, {
+        maxRetries: 15,
+        retryDelay: 1000,
+        signal: abortController.signal,
+        onRetry: (attempt, bytes) => {
+          console.log(`Retrying connection #${attempt} at ${formatBytes(bytes)}`);
+        },
+        onTotalSize: (size) => (totalBytes = size)
+      });
+
+      if (mix && fileHandle) {
+        const mixProcessor = new MixedProcessor({
+          reader: rawStream.getReader(),
+          fileHandle,
+          format: format as 'aac' | 'flac' | 'wav',
+          excludedTracks: excludedTracks.size > 0 ? excludedTracks : undefined,
+          onProgress: updateStats
+        });
+        processor = mixProcessor;
+        await mixProcessor.start();
+      } else if (directoryHandle) {
+        const multiProcessor = new MinizelProcessor({
+          reader: rawStream.getReader(),
+          directoryHandle,
+          format,
+          excludedTracks: excludedTracks.size > 0 ? excludedTracks : undefined,
+          onFileName: getFileName,
+          onTrackDiscovered,
+          onProgress: updateStats
+        });
+        processor = multiProcessor;
+        await multiProcessor.start();
+      }
+
+      updateStats(true); // Force final stats update
+      processState = 'complete';
+    } catch (e) {
+      if (e instanceof Error && e.name === 'AbortError') {
+        processState = 'idle';
+        return;
+      }
+      console.error('Minizel error:', e);
+      errorMessage = e instanceof Error ? e.message : String(e);
+      processState = 'error';
+    } finally {
+      processor = null;
+    }
+  }
+
+  function resetFavicon() {
+    const icon = document.querySelector('link[rel="icon"]') as HTMLLinkElement;
+    if (icon) {
+      icon.type = 'image/x-icon';
+      icon.href = '/favicon.ico';
+    }
+  }
+
+  async function handleCancel() {
+    if ((processState === 'processing' || processState === 'downloading') && processor) {
+      processor.abort();
+      try {
+        await processor.cleanup();
+      } catch (e) {
+        console.error('Cleanup error:', e);
+      }
+      processor = null;
+    }
+
+    resetFavicon();
+    onclose?.();
+  }
+
+  // Update favicon based on processing state
+  $effect(() => {
+    if (iconElem && (processState === 'downloading' || processState === 'processing' || processState === 'complete')) {
+      iconElem.type = 'image/png';
+      iconElem.href = `/assets/favicons/job-${processState === 'complete' ? 'complete' : 'running'}.png`;
+    } else if (iconElem) {
+      iconElem.type = 'image/x-icon';
+      iconElem.href = '/favicon.ico';
+    }
+  });
+
+  onMount(() => {
+    iconElem = document.querySelector('link[rel="icon"]') as HTMLLinkElement;
+  });
+
+  onDestroy(() => {
+    if ((processState === 'processing' || processState === 'downloading') && processor) {
+      processor.abort();
+      processor.cleanup().catch(() => {});
+    }
+    resetFavicon();
+  });
+</script>
+
+<Modal>
+  {#snippet title()}
+    {$t('download.minizel.title')}
+    <span class="rounded-full bg-purple-400 px-2 py-1 text-xs font-bold uppercase text-black">{$t('common.beta')}</span>
+  {/snippet}
+  {#if processState === 'idle'}
+    <div class="text-sm sm:text-base">
+      {#if mix}
+        <p>{$t('download.minizel.mix_description')}</p>
+      {:else}
+        <p>{$t('download.minizel.multi_description')}</p>
+      {/if}
+    </div>
+
+    <div class="rounded bg-zinc-800 p-3">
+      <div class="font-medium text-neutral-300">
+        {$t('common.format')}:
+        <span class="text-white">{$t(mix ? 'download.sections.st' : 'download.sections.mt')} {format.toUpperCase()}</span>
+      </div>
+    </div>
+
+    <!-- Track selection -->
+    {#if users.length > 0}
+      <div class="max-h-60 overflow-y-auto rounded bg-zinc-800">
+        <table class="w-full text-sm">
+          <thead class="sticky top-0 z-[2] bg-zinc-700 text-left text-neutral-300">
+            <tr>
+              <th class="w-10 px-3 py-2"></th>
+              <th class="px-3 py-2">{$t('download.minizel.track')}</th>
+            </tr>
+          </thead>
+          <tbody>
+            {#each users as user (user.track)}
+              {@const isIncluded = !excludedTracks.has(user.track)}
+              <tr
+                class="cursor-pointer border-t border-zinc-700 transition-colors hover:bg-zinc-700/50"
+                class:opacity-50={!isIncluded}
+                onclick={() => toggleTrackExclusion(user.track)}
+              >
+                <td class="px-3 py-2 text-center" onclick={(e) => e.stopPropagation()}>
+                  <Checkbox checked={isIncluded} onchange={() => toggleTrackExclusion(user.track)} />
+                </td>
+                <td class="px-3 py-2">
+                  <RecordingUserChip {user} />
+                </td>
+              </tr>
+            {/each}
+          </tbody>
+        </table>
+      </div>
+    {/if}
+  {:else if processState === 'selecting'}
+    <div class="flex items-center justify-center gap-3 py-8">
+      <Icon icon={loadingIcon} class="h-8 w-8 animate-spin text-teal-400" />
+      <span class="text-lg">{$t('download.minizel.selecting')}</span>
+    </div>
+  {:else if processState === 'downloading' || processState === 'processing'}
+    <div class="flex flex-col gap-3">
+      <div class="rounded bg-zinc-800 p-3">
+        <div class="text-xs font-medium text-neutral-300">
+          {$t('common.format')}:
+          <span class="text-white">{$t(mix ? 'download.sections.st' : 'download.sections.mt')} {format.toUpperCase()}</span>
+        </div>
+      </div>
+
+      <div class="rounded bg-zinc-800 p-3">
+        <div class="flex items-center gap-3">
+          {#if processState === 'downloading'}
+            <Icon icon={downloadIcon} class="h-6 w-6 text-blue-400" />
+            <div class="flex-1">
+              <div class="text-sm font-medium text-white">{$t('common.downloading')}</div>
+              <div class="text-xs text-neutral-400">
+                {formatBytes(downloadedBytes)}{#if totalBytes > 0}{' / '}{formatBytes(totalBytes)}{/if}
+                {#if currentDownloadSpeed > 0}
+                  • {formatSpeed(currentDownloadSpeed)}{/if}
+              </div>
+            </div>
+          {:else}
+            <Icon icon={cogIcon} class="h-6 w-6 animate-spin text-purple-400" />
+            <div class="flex-1">
+              <div class="text-sm font-medium text-white">{$t('common.processing')}</div>
+              <div class="text-xs text-neutral-400">{$t('download.minizel.processing_desc')}</div>
+            </div>
+          {/if}
+          <div class="text-right font-mono text-sm text-neutral-300">
+            {convertToTimeMark(elapsedMs / 1000)}
+          </div>
+        </div>
+
+        <div class="mt-2 h-1.5 overflow-hidden rounded-full bg-zinc-700">
+          {#if totalBytes > 0}
+            <div
+              class="h-full rounded-full transition-all duration-300"
+              class:bg-blue-500={processState === 'downloading'}
+              class:bg-purple-500={processState === 'processing'}
+              style="width: {downloadProgress}%"
+            ></div>
+          {/if}
+        </div>
+        <div class="flex items-center justify-between gap-4 text-xs text-neutral-400">
+          <span>
+            {#if processState === 'downloading'}
+              {$t('download.minizel.download_pause_warning')}
+            {/if}
+          </span>
+          <div class="flex flex-wrap items-center gap-2">
+            <span>{$t('download.minizel.buffered')}: <span class="font-mono text-neutral-300">{formatBytes(heldBytes)}</span></span>
+            <span>{$t('download.minizel.write_speed')}: <span class="font-mono text-neutral-300">{formatSpeed(currentWriteSpeed)}</span></span>
+            <!-- <span>Total Written: <span class="font-mono text-neutral-300">{formatBytes(bytesWritten)}</span></span> -->
+          </div>
+        </div>
+      </div>
+
+      {#if mix}
+        <!-- Mix progress -->
+        <div class="rounded bg-zinc-800 p-3">
+          <div class="flex items-center justify-between text-sm">
+            <span class="text-neutral-300">{$t('download.minizel.position')}</span>
+            <span class="font-mono text-white">{convertToTimeMark(mixPosition / 48000)}</span>
+          </div>
+        </div>
+      {:else}
+        <!-- Per-track progress - show all users -->
+        <div class="max-h-60 overflow-y-auto rounded bg-zinc-800">
+          <table class="w-full text-sm">
+            <thead class="sticky top-0 z-[2] bg-zinc-700 text-left text-neutral-300">
+              <tr>
+                <th class="px-3 py-2">{$t('download.minizel.track')}</th>
+                <th class="px-3 py-2 text-right">{$t('download.minizel.written')}</th>
+                <th class="px-3 py-2 text-right">{$t('download.minizel.position')}</th>
+              </tr>
+            </thead>
+            <tbody>
+              {#each users as user (user.track)}
+                {@const stats = trackStatsMap.get(user.track)}
+                {@const isExcluded = excludedTracks.has(user.track)}
+                <tr class="border-t border-zinc-700" class:opacity-50={isExcluded}>
+                  <td class="px-3 py-2">
+                    <RecordingUserChip {user} />
+                  </td>
+                  <td class="px-3 py-2 text-right font-mono text-neutral-300">
+                    {#if isExcluded}
+                      <span class="text-neutral-500">{$t('download.minizel.excluded')}</span>
+                    {:else if stats}
+                      {formatBytes(stats.bytesWritten)}
+                    {:else}
+                      <Icon icon={loadingIcon} class="inline h-3 w-3 animate-spin" />
+                    {/if}
+                  </td>
+                  <td class="px-3 py-2 text-right font-mono text-neutral-300">
+                    {#if isExcluded}
+                      —
+                    {:else if stats}
+                      {convertToTimeMark(stats.position / 48000)}
+                    {:else}
+                      —
+                    {/if}
+                  </td>
+                </tr>
+              {/each}
+            </tbody>
+          </table>
+        </div>
+      {/if}
+    </div>
+  {:else if processState === 'complete'}
+    <div class="flex flex-col items-center gap-4 py-4">
+      <Icon icon={checkIcon} class="h-12 w-12 text-green-500" />
+      <div class="text-center">
+        <p class="text-lg font-medium text-white">{$t('download.minizel.complete_message')}</p>
+        <p class="text-sm text-neutral-400">
+          {$t('download.minizel.complete_stats', {
+            values: {
+              time: convertToTimeMark(elapsedMs / 1000),
+              size: formatBytes(bytesWritten)
+            }
+          })}
+        </p>
+      </div>
+    </div>
+
+    <!-- Show final track stats for multi-track -->
+    {#if !mix && users.length > 0}
+      <div class="max-h-48 overflow-y-auto rounded bg-zinc-800">
+        <table class="w-full text-sm">
+          <thead class="sticky top-0 z-[2] bg-zinc-700 text-left text-neutral-300">
+            <tr>
+              <th class="px-3 py-2">{$t('download.minizel.track')}</th>
+              <th class="px-3 py-2 text-right">{$t('download.minizel.written')}</th>
+              <th class="px-3 py-2 text-right">{$t('download.minizel.position')}</th>
+            </tr>
+          </thead>
+          <tbody>
+            {#each users as user (user.track)}
+              {@const stats = trackStatsMap.get(user.track)}
+              {@const isExcluded = excludedTracks.has(user.track)}
+              <tr class="border-t border-zinc-700" class:opacity-50={isExcluded}>
+                <td class="px-3 py-2">
+                  <RecordingUserChip {user} />
+                </td>
+                <td class="px-3 py-2 text-right font-mono text-neutral-300">
+                  {#if isExcluded}
+                    <span class="text-neutral-500">{$t('download.minizel.excluded')}</span>
+                  {:else if stats}
+                    {formatBytes(stats.bytesWritten)}
+                  {:else}
+                    —
+                  {/if}
+                </td>
+                <td class="px-3 py-2 text-right font-mono text-neutral-300">
+                  {#if isExcluded}
+                    —
+                  {:else if stats}
+                    {convertToTimeMark(stats.position / 48000)}
+                  {:else}
+                    —
+                  {/if}
+                </td>
+              </tr>
+            {/each}
+          </tbody>
+        </table>
+      </div>
+    {/if}
+  {:else if processState === 'error'}
+    <div class="flex flex-col items-center gap-4 py-6">
+      <Icon icon={errorIcon} class="h-16 w-16 text-red-500" />
+      <div class="text-center">
+        <p class="text-lg font-medium text-white">{$t('download.minizel.error_message')}</p>
+        <p class="text-sm text-red-400">{errorMessage}</p>
+      </div>
+    </div>
+  {/if}
+
+  {#snippet buttons()}
+    {#if processState === 'idle'}
+      <Button onclick={onclose}>
+        {$t('common.cancel')}
+      </Button>
+      <Button primary onclick={startProcessing} disabled={isAllExcluded()}>
+        {$t('download.minizel.start')}
+      </Button>
+    {:else if processState === 'downloading' || processState === 'processing'}
+      <Button onclick={handleCancel}>
+        {$t('download.minizel.cancel')}
+      </Button>
+    {:else}
+      <Button primary onclick={onclose}>
+        {$t('common.close')}
+      </Button>
+    {/if}
+  {/snippet}
+</Modal>
diff --git a/apps/ferret/vite.config.ts b/apps/ferret/vite.config.ts
index 573547e5..4f7d11a8 100644
--- a/apps/ferret/vite.config.ts
+++ b/apps/ferret/vite.config.ts
@@ -1,13 +1,62 @@
+import { createReadStream } from 'node:fs';
+import { access, cp, mkdir } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
 import { enhancedImages } from '@sveltejs/enhanced-img';
 import { sveltekit } from '@sveltejs/kit/vite';
-import { defineConfig } from 'vite';
+import mime from 'mime';
+import { defineConfig, type PluginOption } from 'vite';
 import devtoolsJson from 'vite-plugin-devtools-json';
 
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+
+async function pathExists(path: string) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const exposeLibAV: PluginOption = (() => {
+  const MODULE_DIR = join(__dirname, 'node_modules/@libav.js/variant-webcodecs/dist');
+  return {
+    name: 'vite-libav.js',
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        if (!req.url?.startsWith('/_libav/')) return next();
+
+        const filename = basename(req.url).split('?')[0];
+        if (!filename) return next();
+
+        const fileExists = await pathExists(join(MODULE_DIR, filename));
+        if (!fileExists) return next();
+
+        const fileType = mime.getType(filename);
+        if (!fileType) return next();
+
+        res.setHeader('Content-Type', fileType);
+        return createReadStream(join(MODULE_DIR, filename)).pipe(res);
+      });
+    },
+    generateBundle: async (options) => {
+      if (!options.dir) return;
+
+      const assets = join(options.dir, '_libav');
+      await mkdir(assets, { recursive: true });
+      await cp(MODULE_DIR, assets, { recursive: true });
+    }
+  };
+})();
+
 export default defineConfig({
-  plugins: [enhancedImages(), sveltekit(), devtoolsJson()],
+  plugins: [enhancedImages(), sveltekit(), devtoolsJson(), exposeLibAV],
   server: {
     fs: { allow: ['../../locale'] },
-    allowedHosts: ['.trycloudflare.com']
+    allowedHosts: ['.trycloudflare.com'],
+    hmr: { timeout: 60000 }
   },
   ssr: {
     external: ['@craig/db']
diff --git a/nginx.conf b/nginx.conf
index e81d6219..93bb4307 100644
--- a/nginx.conf
+++ b/nginx.conf
@@ -28,6 +28,22 @@ server {
       proxy_cache off;
     }
 
+    location ~* ^/api/v1/recordings/\w+/raw\.dat(?:$|\?) {
+      proxy_pass http://localhost:9100;
+      proxy_set_header Host $host;
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_http_version 1.1;
+      proxy_set_header Connection "";
+      proxy_buffering off;
+      proxy_cache off;
+      proxy_read_timeout 3600s;
+      proxy_send_timeout 3600s;
+      proxy_connect_timeout 60s;
+      send_timeout 3600s;
+      keepalive_timeout 3600s;
+    }
+
     location = /api/ennuizel {
       proxy_pass http://localhost:9001;
       proxy_redirect off;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 687a1d22..001e8447 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -240,6 +240,15 @@ importers:
       '@craig/logger':
         specifier: workspace:*
         version: link:../../packages/logger
+      '@henrygd/queue':
+        specifier: ^1.0.7
+        version: 1.2.0
+      '@libav.js/variant-webcodecs':
+        specifier: ^6.8.8
+        version: 6.8.8
+      '@wasm-audio-decoders/flac':
+        specifier: ^0.2.8
+        version: 0.2.10
       destr:
         specifier: ^2.0.5
         version: 2.0.5
@@ -255,9 +264,15 @@ importers:
       just-clone:
         specifier: ^6.2.0
         version: 6.2.0
+      mediabunny:
+        specifier: ^1.21.1
+        version: 1.27.2
       nanoid:
         specifier: ^5.1.6
         version: 5.1.6
+      opus-decoder:
+        specifier: ^0.7.10
+        version: 0.7.11
       zod:
         specifier: ^4.3.5
         version: 4.3.5
@@ -310,6 +325,9 @@ importers:
       '@sveltejs/vite-plugin-svelte':
         specifier: ^6.2.4
         version: 6.2.4(svelte@5.46.4)(vite@7.3.1(@types/node@25.0.9)(jiti@1.21.7)(lightningcss@1.30.2)(sass@1.97.2)(tsx@4.19.4)(yaml@2.7.0))
+      '@types/wicg-file-system-access':
+        specifier: ^2023.10.6
+        version: 2023.10.7
       autoprefixer:
         specifier: ^10.4.23
         version: 10.4.23(postcss@8.5.6)
@@ -328,6 +346,9 @@ importers:
       just-range:
         specifier: ^4.2.0
         version: 4.2.0
+      mime:
+        specifier: ^4.1.0
+        version: 4.1.0
       postcss:
         specifier: ^8.5.6
         version: 8.5.6
@@ -1002,6 +1023,9 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@eshaz/web-worker@1.2.2':
+    resolution: {integrity: sha512-WxXiHFmD9u/owrzempiDlBB1ZYqiLnm9s6aPc8AlFQalq2tKmqdmMr9GXOupDgzXtqnBipj8Un0gkIm7Sjf8mw==}
+
   '@eslint-community/eslint-utils@4.4.1':
     resolution: {integrity: sha512-s3O3waFUrMV8P/XaF/+ZTp1X9XBZW1a4B97ZnjQF2KYWaFD2A8KyFBsrsfSjEmjn3RGWAIuvlneuZm3CUK3jbA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -1078,6 +1102,9 @@ packages:
   '@formatjs/intl-localematcher@0.6.2':
     resolution: {integrity: sha512-XOMO2Hupl0wdd172Y06h6kLpBz6Dv+J4okPLl4LPtzbr8f66WbIoy4ev98EBuZ6ZK4h5ydTN6XneT4QVpD7cdA==}
 
+  '@henrygd/queue@1.2.0':
+    resolution: {integrity: sha512-jW/BLSTpcvExDhqJGxtIPgGr2O0IFF8XUNDwEbfCfhrXT8a4xztQ9Lv6U/vbYzYC0xVWn+3zv6YnLUh3bEFUKA==}
+
   '@henrygd/semaphore@0.1.0':
     resolution: {integrity: sha512-5wRPsfP9iWnOTFRd7QKdHlWTgY9xw9GAHSkQP/Q05ZTKUBdfTj44BhsnADPfvBoUQVGDtP2Nd0UShVdeTLuLwA==}
 
@@ -1434,8 +1461,8 @@ packages:
   '@jridgewell/trace-mapping@0.3.25':
     resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==}
 
-  '@jridgewell/trace-mapping@0.3.31':
-    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
+  '@libav.js/variant-webcodecs@6.8.8':
+    resolution: {integrity: sha512-nu2c7GaYc+KIJcopRrGUMbK4whyf4xDOoiJx7avOpDir06uDwYl42hjx0P8QcDsmFFS5l0wLg6d767ezMRfU0A==}
 
   '@microsoft/api-extractor-model@7.31.0':
     resolution: {integrity: sha512-DqbB4G33bYTsS8hxdmyjpLXjQTjf/05Jsk82d4ldb5UaYi5kt7imJDcSJh5K+bgJXLBn63MAPAJTUNVXsniFCQ==}
@@ -1651,11 +1678,6 @@ packages:
     cpu: [arm]
     os: [android]
 
-  '@rollup/rollup-android-arm-eabi@4.52.3':
-    resolution: {integrity: sha512-h6cqHGZ6VdnwliFG1NXvMPTy/9PS3h8oLh7ImwR+kl+oYnQizgjxsONmmPSb2C66RksfkfIxEVtDSEcJiO0tqw==}
-    cpu: [arm]
-    os: [android]
-
   '@rollup/rollup-android-arm-eabi@4.55.1':
     resolution: {integrity: sha512-9R0DM/ykwfGIlNu6+2U09ga0WXeZ9MRC2Ter8jnz8415VbuIykVuc6bhdrbORFZANDmTDvq26mJrEVTl8TdnDg==}
     cpu: [arm]
@@ -1671,11 +1693,6 @@ packages:
     cpu: [arm64]
     os: [android]
 
-  '@rollup/rollup-android-arm64@4.52.3':
-    resolution: {integrity: sha512-wd+u7SLT/u6knklV/ifG7gr5Qy4GUbH2hMWcDauPFJzmCZUAJ8L2bTkVXC2niOIxp8lk3iH/QX8kSrUxVZrOVw==}
-    cpu: [arm64]
-    os: [android]
-
   '@rollup/rollup-android-arm64@4.55.1':
     resolution: {integrity: sha512-eFZCb1YUqhTysgW3sj/55du5cG57S7UTNtdMjCW7LwVcj3dTTcowCsC8p7uBdzKsZYa8J7IDE8lhMI+HX1vQvg==}
     cpu: [arm64]
@@ -1691,11 +1708,6 @@ packages:
     cpu: [arm64]
     os: [darwin]
 
-  '@rollup/rollup-darwin-arm64@4.52.3':
-    resolution: {integrity: sha512-lj9ViATR1SsqycwFkJCtYfQTheBdvlWJqzqxwc9f2qrcVrQaF/gCuBRTiTolkRWS6KvNxSk4KHZWG7tDktLgjg==}
-    cpu: [arm64]
-    os: [darwin]
-
   '@rollup/rollup-darwin-arm64@4.55.1':
     resolution: {integrity: sha512-p3grE2PHcQm2e8PSGZdzIhCKbMCw/xi9XvMPErPhwO17vxtvCN5FEA2mSLgmKlCjHGMQTP6phuQTYWUnKewwGg==}
     cpu: [arm64]
@@ -1711,11 +1723,6 @@ packages:
     cpu: [x64]
     os: [darwin]
 
-  '@rollup/rollup-darwin-x64@4.52.3':
-    resolution: {integrity: sha512-+Dyo7O1KUmIsbzx1l+4V4tvEVnVQqMOIYtrxK7ncLSknl1xnMHLgn7gddJVrYPNZfEB8CIi3hK8gq8bDhb3h5A==}
-    cpu: [x64]
-    os: [darwin]
-
   '@rollup/rollup-darwin-x64@4.55.1':
     resolution: {integrity: sha512-rDUjG25C9qoTm+e02Esi+aqTKSBYwVTaoS1wxcN47/Luqef57Vgp96xNANwt5npq9GDxsH7kXxNkJVEsWEOEaQ==}
     cpu: [x64]
@@ -1731,11 +1738,6 @@ packages:
     cpu: [arm64]
     os: [freebsd]
 
-  '@rollup/rollup-freebsd-arm64@4.52.3':
-    resolution: {integrity: sha512-u9Xg2FavYbD30g3DSfNhxgNrxhi6xVG4Y6i9Ur1C7xUuGDW3banRbXj+qgnIrwRN4KeJ396jchwy9bCIzbyBEQ==}
-    cpu: [arm64]
-    os: [freebsd]
-
   '@rollup/rollup-freebsd-arm64@4.55.1':
     resolution: {integrity: sha512-+JiU7Jbp5cdxekIgdte0jfcu5oqw4GCKr6i3PJTlXTCU5H5Fvtkpbs4XJHRmWNXF+hKmn4v7ogI5OQPaupJgOg==}
     cpu: [arm64]
@@ -1751,11 +1753,6 @@ packages:
     cpu: [x64]
     os: [freebsd]
 
-  '@rollup/rollup-freebsd-x64@4.52.3':
-    resolution: {integrity: sha512-5M8kyi/OX96wtD5qJR89a/3x5x8x5inXBZO04JWhkQb2JWavOWfjgkdvUqibGJeNNaz1/Z1PPza5/tAPXICI6A==}
-    cpu: [x64]
-    os: [freebsd]
-
   '@rollup/rollup-freebsd-x64@4.55.1':
     resolution: {integrity: sha512-V5xC1tOVWtLLmr3YUk2f6EJK4qksksOYiz/TCsFHu/R+woubcLWdC9nZQmwjOAbmExBIVKsm1/wKmEy4z4u4Bw==}
     cpu: [x64]
@@ -1771,11 +1768,6 @@ packages:
     cpu: [arm]
     os: [linux]
 
-  '@rollup/rollup-linux-arm-gnueabihf@4.52.3':
-    resolution: {integrity: sha512-IoerZJ4l1wRMopEHRKOO16e04iXRDyZFZnNZKrWeNquh5d6bucjezgd+OxG03mOMTnS1x7hilzb3uURPkJ0OfA==}
-    cpu: [arm]
-    os: [linux]
-
   '@rollup/rollup-linux-arm-gnueabihf@4.55.1':
     resolution: {integrity: sha512-Rn3n+FUk2J5VWx+ywrG/HGPTD9jXNbicRtTM11e/uorplArnXZYsVifnPPqNNP5BsO3roI4n8332ukpY/zN7rQ==}
     cpu: [arm]
@@ -1791,11 +1783,6 @@ packages:
     cpu: [arm]
     os: [linux]
 
-  '@rollup/rollup-linux-arm-musleabihf@4.52.3':
-    resolution: {integrity: sha512-ZYdtqgHTDfvrJHSh3W22TvjWxwOgc3ThK/XjgcNGP2DIwFIPeAPNsQxrJO5XqleSlgDux2VAoWQ5iJrtaC1TbA==}
-    cpu: [arm]
-    os: [linux]
-
   '@rollup/rollup-linux-arm-musleabihf@4.55.1':
     resolution: {integrity: sha512-grPNWydeKtc1aEdrJDWk4opD7nFtQbMmV7769hiAaYyUKCT1faPRm2av8CX1YJsZ4TLAZcg9gTR1KvEzoLjXkg==}
     cpu: [arm]
@@ -1811,11 +1798,6 @@ packages:
     cpu: [arm64]
     os: [linux]
 
-  '@rollup/rollup-linux-arm64-gnu@4.52.3':
-    resolution: {integrity: sha512-NcViG7A0YtuFDA6xWSgmFb6iPFzHlf5vcqb2p0lGEbT+gjrEEz8nC/EeDHvx6mnGXnGCC1SeVV+8u+smj0CeGQ==}
-    cpu: [arm64]
-    os: [linux]
-
   '@rollup/rollup-linux-arm64-gnu@4.55.1':
     resolution: {integrity: sha512-a59mwd1k6x8tXKcUxSyISiquLwB5pX+fJW9TkWU46lCqD/GRDe9uDN31jrMmVP3feI3mhAdvcCClhV8V5MhJFQ==}
     cpu: [arm64]
@@ -1831,21 +1813,11 @@ packages:
     cpu: [arm64]
     os: [linux]
 
-  '@rollup/rollup-linux-arm64-musl@4.52.3':
-    resolution: {integrity: sha512-d3pY7LWno6SYNXRm6Ebsq0DJGoiLXTb83AIPCXl9fmtIQs/rXoS8SJxxUNtFbJ5MiOvs+7y34np77+9l4nfFMw==}
-    cpu: [arm64]
-    os: [linux]
-
   '@rollup/rollup-linux-arm64-musl@4.55.1':
     resolution: {integrity: sha512-puS1MEgWX5GsHSoiAsF0TYrpomdvkaXm0CofIMG5uVkP6IBV+ZO9xhC5YEN49nsgYo1DuuMquF9+7EDBVYu4uA==}
     cpu: [arm64]
     os: [linux]
 
-  '@rollup/rollup-linux-loong64-gnu@4.52.3':
-    resolution: {integrity: sha512-3y5GA0JkBuirLqmjwAKwB0keDlI6JfGYduMlJD/Rl7fvb4Ni8iKdQs1eiunMZJhwDWdCvrcqXRY++VEBbvk6Eg==}
-    cpu: [loong64]
-    os: [linux]
-
   '@rollup/rollup-linux-loong64-gnu@4.55.1':
     resolution: {integrity: sha512-r3Wv40in+lTsULSb6nnoudVbARdOwb2u5fpeoOAZjFLznp6tDU8kd+GTHmJoqZ9lt6/Sys33KdIHUaQihFcu7g==}
     cpu: [loong64]
@@ -1876,11 +1848,6 @@ packages:
     cpu: [ppc64]
     os: [linux]
 
-  '@rollup/rollup-linux-ppc64-gnu@4.52.3':
-    resolution: {integrity: sha512-AUUH65a0p3Q0Yfm5oD2KVgzTKgwPyp9DSXc3UA7DtxhEb/WSPfbG4wqXeSN62OG5gSo18em4xv6dbfcUGXcagw==}
-    cpu: [ppc64]
-    os: [linux]
-
   '@rollup/rollup-linux-ppc64-gnu@4.55.1':
     resolution: {integrity: sha512-3KhoECe1BRlSYpMTeVrD4sh2Pw2xgt4jzNSZIIPLFEsnQn9gAnZagW9+VqDqAHgm1Xc77LzJOo2LdigS5qZ+gw==}
     cpu: [ppc64]
@@ -1901,11 +1868,6 @@ packages:
     cpu: [riscv64]
     os: [linux]
 
-  '@rollup/rollup-linux-riscv64-gnu@4.52.3':
-    resolution: {integrity: sha512-1makPhFFVBqZE+XFg3Dkq+IkQ7JvmUrwwqaYBL2CE+ZpxPaqkGaiWFEWVGyvTwZace6WLJHwjVh/+CXbKDGPmg==}
-    cpu: [riscv64]
-    os: [linux]
-
   '@rollup/rollup-linux-riscv64-gnu@4.55.1':
     resolution: {integrity: sha512-uW0Y12ih2XJRERZ4jAfKamTyIHVMPQnTZcQjme2HMVDAHY4amf5u414OqNYC+x+LzRdRcnIG1YodLrrtA8xsxw==}
     cpu: [riscv64]
@@ -1916,11 +1878,6 @@ packages:
     cpu: [riscv64]
     os: [linux]
 
-  '@rollup/rollup-linux-riscv64-musl@4.52.3':
-    resolution: {integrity: sha512-OOFJa28dxfl8kLOPMUOQBCO6z3X2SAfzIE276fwT52uXDWUS178KWq0pL7d6p1kz7pkzA0yQwtqL0dEPoVcRWg==}
-    cpu: [riscv64]
-    os: [linux]
-
   '@rollup/rollup-linux-riscv64-musl@4.55.1':
     resolution: {integrity: sha512-u9yZ0jUkOED1BFrqu3BwMQoixvGHGZ+JhJNkNKY/hyoEgOwlqKb62qu+7UjbPSHYjiVy8kKJHvXKv5coH4wDeg==}
     cpu: [riscv64]
@@ -1936,11 +1893,6 @@ packages:
     cpu: [s390x]
     os: [linux]
 
-  '@rollup/rollup-linux-s390x-gnu@4.52.3':
-    resolution: {integrity: sha512-jMdsML2VI5l+V7cKfZx3ak+SLlJ8fKvLJ0Eoa4b9/vCUrzXKgoKxvHqvJ/mkWhFiyp88nCkM5S2v6nIwRtPcgg==}
-    cpu: [s390x]
-    os: [linux]
-
   '@rollup/rollup-linux-s390x-gnu@4.55.1':
     resolution: {integrity: sha512-/0PenBCmqM4ZUd0190j7J0UsQ/1nsi735iPRakO8iPciE7BQ495Y6msPzaOmvx0/pn+eJVVlZrNrSh4WSYLxNg==}
     cpu: [s390x]
@@ -1956,11 +1908,6 @@ packages:
     cpu: [x64]
     os: [linux]
 
-  '@rollup/rollup-linux-x64-gnu@4.52.3':
-    resolution: {integrity: sha512-tPgGd6bY2M2LJTA1uGq8fkSPK8ZLYjDjY+ZLK9WHncCnfIz29LIXIqUgzCR0hIefzy6Hpbe8Th5WOSwTM8E7LA==}
-    cpu: [x64]
-    os: [linux]
-
   '@rollup/rollup-linux-x64-gnu@4.55.1':
     resolution: {integrity: sha512-a8G4wiQxQG2BAvo+gU6XrReRRqj+pLS2NGXKm8io19goR+K8lw269eTrPkSdDTALwMmJp4th2Uh0D8J9bEV1vg==}
     cpu: [x64]
@@ -1976,11 +1923,6 @@ packages:
     cpu: [x64]
     os: [linux]
 
-  '@rollup/rollup-linux-x64-musl@4.52.3':
-    resolution: {integrity: sha512-BCFkJjgk+WFzP+tcSMXq77ymAPIxsX9lFJWs+2JzuZTLtksJ2o5hvgTdIcZ5+oKzUDMwI0PfWzRBYAydAHF2Mw==}
-    cpu: [x64]
-    os: [linux]
-
   '@rollup/rollup-linux-x64-musl@4.55.1':
     resolution: {integrity: sha512-bD+zjpFrMpP/hqkfEcnjXWHMw5BIghGisOKPj+2NaNDuVT+8Ds4mPf3XcPHuat1tz89WRL+1wbcxKY3WSbiT7w==}
     cpu: [x64]
@@ -1991,11 +1933,6 @@ packages:
     cpu: [x64]
     os: [openbsd]
 
-  '@rollup/rollup-openharmony-arm64@4.52.3':
-    resolution: {integrity: sha512-KTD/EqjZF3yvRaWUJdD1cW+IQBk4fbQaHYJUmP8N4XoKFZilVL8cobFSTDnjTtxWJQ3JYaMgF4nObY/+nYkumA==}
-    cpu: [arm64]
-    os: [openharmony]
-
   '@rollup/rollup-openharmony-arm64@4.55.1':
     resolution: {integrity: sha512-xzm44KgEP11te3S2HCSyYf5zIzWmx3n8HDCc7EE59+lTcswEWNpvMLfd9uJvVX8LCg9QWG67Xt75AuHn4vgsXw==}
     cpu: [arm64]
@@ -2011,11 +1948,6 @@ packages:
     cpu: [arm64]
     os: [win32]
 
-  '@rollup/rollup-win32-arm64-msvc@4.52.3':
-    resolution: {integrity: sha512-+zteHZdoUYLkyYKObGHieibUFLbttX2r+58l27XZauq0tcWYYuKUwY2wjeCN9oK1Um2YgH2ibd6cnX/wFD7DuA==}
-    cpu: [arm64]
-    os: [win32]
-
   '@rollup/rollup-win32-arm64-msvc@4.55.1':
     resolution: {integrity: sha512-yR6Bl3tMC/gBok5cz/Qi0xYnVbIxGx5Fcf/ca0eB6/6JwOY+SRUcJfI0OpeTpPls7f194as62thCt/2BjxYN8g==}
     cpu: [arm64]
@@ -2031,21 +1963,11 @@ packages:
     cpu: [ia32]
     os: [win32]
 
-  '@rollup/rollup-win32-ia32-msvc@4.52.3':
-    resolution: {integrity: sha512-of1iHkTQSo3kr6dTIRX6t81uj/c/b15HXVsPcEElN5sS859qHrOepM5p9G41Hah+CTqSh2r8Bm56dL2z9UQQ7g==}
-    cpu: [ia32]
-    os: [win32]
-
   '@rollup/rollup-win32-ia32-msvc@4.55.1':
     resolution: {integrity: sha512-3fZBidchE0eY0oFZBnekYCfg+5wAB0mbpCBuofh5mZuzIU/4jIVkbESmd2dOsFNS78b53CYv3OAtwqkZZmU5nA==}
     cpu: [ia32]
     os: [win32]
 
-  '@rollup/rollup-win32-x64-gnu@4.52.3':
-    resolution: {integrity: sha512-s0hybmlHb56mWVZQj8ra9048/WZTPLILKxcvcq+8awSZmyiSUZjjem1AhU3Tf4ZKpYhK4mg36HtHDOe8QJS5PQ==}
-    cpu: [x64]
-    os: [win32]
-
   '@rollup/rollup-win32-x64-gnu@4.55.1':
     resolution: {integrity: sha512-xGGY5pXj69IxKb4yv/POoocPy/qmEGhimy/FoTpTSVju3FYXUQQMFCaZZXJVidsmGxRioZAwpThl/4zX41gRKg==}
     cpu: [x64]
@@ -2061,11 +1983,6 @@ packages:
     cpu: [x64]
     os: [win32]
 
-  '@rollup/rollup-win32-x64-msvc@4.52.3':
-    resolution: {integrity: sha512-zGIbEVVXVtauFgl3MRwGWEN36P5ZGenHRMgNw88X5wEhEBpq0XrMEZwOn07+ICrwM17XO5xfMZqh0OldCH5VTA==}
-    cpu: [x64]
-    os: [win32]
-
   '@rollup/rollup-win32-x64-msvc@4.55.1':
     resolution: {integrity: sha512-SPEpaL6DX4rmcXtnhdrQYgzQ5W2uW3SCJch88lB2zImhJRhIIK44fkUrgIV/Q8yUNfw5oyZ5vkeQsZLhCb06lw==}
     cpu: [x64]
@@ -2272,6 +2189,12 @@ packages:
   '@types/cookie@0.6.0':
     resolution: {integrity: sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==}
 
+  '@types/dom-mediacapture-transform@0.1.11':
+    resolution: {integrity: sha512-Y2p+nGf1bF2XMttBnsVPHUWzRRZzqUoJAKmiP10b5umnO6DDrWI0BrGDJy1pOHoOULVmGSfFNkQrAlC5dcj6nQ==}
+
+  '@types/dom-webcodecs@0.1.13':
+    resolution: {integrity: sha512-O5hkiFIcjjszPIYyUSyvScyvrBoV3NOEEZx/pMlsu44TKzWNkLVBBxnxJz42in5n3QIolYOcBYFCPZZ0h8SkwQ==}
+
   '@types/estree@1.0.6':
     resolution: {integrity: sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==}
 
@@ -2317,6 +2240,9 @@ packages:
   '@types/triple-beam@1.3.2':
     resolution: {integrity: sha512-txGIh+0eDFzKGC25zORnswy+br1Ha7hj5cMVwKIU7+s0U2AxxJru/jZSMU6OC9MJWP6+pc/hc6ZjyZShpsyY2g==}
 
+  '@types/wicg-file-system-access@2023.10.7':
+    resolution: {integrity: sha512-g49ijasEJvCd7ifmAY2D0wdEtt1xRjBbA33PJTiv8mKBr7DoMsPeISoJ8oQOTopSRi+FBWPpPW5ouDj2QPKtGA==}
+
   '@typescript-eslint/eslint-plugin@8.25.0':
     resolution: {integrity: sha512-VM7bpzAe7JO/BFf40pIT1lJqS/z1F8OaSsUB3rpFJucQA4cOSuH2RVVVkFULN+En0Djgr29/jb4EQnedUo95KA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@@ -2364,6 +2290,12 @@ packages:
     resolution: {integrity: sha512-kCYXKAum9CecGVHGij7muybDfTS2sD3t0L4bJsEZLkyrXUImiCTq1M3LG2SRtOhiHFwMR9wAFplpT6XHYjTkwQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
+  '@wasm-audio-decoders/common@9.0.7':
+    resolution: {integrity: sha512-WRaUuWSKV7pkttBygml/a6dIEpatq2nnZGFIoPTc5yPLkxL6Wk4YaslPM98OPQvWacvNZ+Py9xROGDtrFBDzag==}
+
+  '@wasm-audio-decoders/flac@0.2.10':
+    resolution: {integrity: sha512-YfcyoD2rYRBa6ffawZKNi5qvV5HArJmNmuMVUPoutuZ2hhGi6WNSWIzgvbROGmPbFivLL764Am7xxJENWJDhjw==}
+
   abstract-logging@2.0.1:
     resolution: {integrity: sha512-2BjRTZxTPvheOvGbBslFSYOUkr+SjPtOnrLP33f+VIWLzezQpZcqVg7ja3L4dBXmzzgwT+a029jRx5PCi3JuiA==}
 
@@ -2632,6 +2564,9 @@ packages:
     resolution: {integrity: sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA==}
     engines: {node: '>=0.10.0'}
 
+  codec-parser@2.5.0:
+    resolution: {integrity: sha512-Ru9t80fV8B0ZiixQl8xhMTLru+dzuis/KQld32/x5T/+3LwZb0/YvQdSKytX9JqCnRdiupvAvyYJINKrXieziQ==}
+
   color-convert@1.9.3:
     resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}
 
@@ -3895,6 +3830,9 @@ packages:
     resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
     engines: {node: '>= 0.4'}
 
+  mediabunny@1.27.2:
+    resolution: {integrity: sha512-0g/vmb6X0xmnzqW0U44weF9CmzcUFFQRHrjzoVpSL2KXuhWIWcW3u9wIcohHiTY78jfr0SauYKLxjOQReaMxXQ==}
+
   memoizee@0.4.17:
     resolution: {integrity: sha512-DGqD7Hjpi/1or4F/aYAspXKNm5Yili0QDAFAY4QYvpqpgiY6+1jOfqpmByzjxbWd/T9mChbCArXAbDAsTm5oXA==}
     engines: {node: '>=0.12'}
@@ -3915,6 +3853,11 @@ packages:
     resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
     engines: {node: '>= 0.6'}
 
+  mime@4.1.0:
+    resolution: {integrity: sha512-X5ju04+cAzsojXKes0B/S4tcYtFAJ6tTMuSPBEn9CPGlrWr8Fiw7qYeLT0XyH80HSoAoqWCaz+MWKh22P7G1cw==}
+    engines: {node: '>=16'}
+    hasBin: true
+
   minimatch@10.0.3:
     resolution: {integrity: sha512-IPZ167aShDZZUMdRk66cyQAW3qr0WzbHkPdMYa8bzZhlHhO3jALbKdxcaak7W9FfT2rZNpQuUu4Od7ILEpXSaw==}
     engines: {node: 20 || >=22}
@@ -4051,6 +3994,9 @@ packages:
     resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
     engines: {node: '>= 0.8.0'}
 
+  opus-decoder@0.7.11:
+    resolution: {integrity: sha512-+e+Jz3vGQLxRTBHs8YJQPRPc1Tr+/aC6coV/DlZylriA29BdHQAYXhvNRKtjftof17OFng0+P4wsFIqQu3a48A==}
+
   own-keys@1.0.1:
     resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
     engines: {node: '>= 0.4'}
@@ -4504,11 +4450,6 @@ packages:
     engines: {node: '>=18.0.0', npm: '>=8.0.0'}
     hasBin: true
 
-  rollup@4.52.3:
-    resolution: {integrity: sha512-RIDh866U8agLgiIcdpB+COKnlCreHJLfIhWC3LVflku5YHfpnsIKigRZeFfMfCc4dVcqNVfQQ5gO/afOck064A==}
-    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
-    hasBin: true
-
   rollup@4.55.1:
     resolution: {integrity: sha512-wDv/Ht1BNHB4upNbK74s9usvl7hObDnvVzknxqY/E/O3X6rW1U1rV1aENEfJ54eFZDTNo7zv1f5N4edCluH7+A==}
     engines: {node: '>=18.0.0', npm: '>=8.0.0'}
@@ -4646,8 +4587,11 @@ packages:
   simple-swizzle@0.2.2:
     resolution: {integrity: sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==}
 
-  sirv@3.0.2:
-    resolution: {integrity: sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==}
+  simple-yenc@1.0.4:
+    resolution: {integrity: sha512-5gvxpSd79e9a3V4QDYUqnqxeD4HGlhCakVpb6gMnDD7lexJggSBJRBO5h52y/iJrdXRilX9UCuDaIJhSWm5OWw==}
+
+  sirv@3.0.0:
+    resolution: {integrity: sha512-BPwJGUeDaDCHihkORDchNyyTvWFhcusy1XMmhEVTQTwGeybFbp8YEmB+njbPnth1FibULBSBVwCQni25XlCUDg==}
     engines: {node: '>=18'}
 
   sonic-boom@4.2.0:
@@ -5500,6 +5444,8 @@ snapshots:
   '@esbuild/win32-x64@0.27.2':
     optional: true
 
+  '@eshaz/web-worker@1.2.2': {}
+
   '@eslint-community/eslint-utils@4.4.1(eslint@9.21.0(jiti@2.6.1))':
     dependencies:
       eslint: 9.21.0(jiti@2.6.1)
@@ -5599,6 +5545,8 @@ snapshots:
     dependencies:
       tslib: 2.8.1
 
+  '@henrygd/queue@1.2.0': {}
+
   '@henrygd/semaphore@0.1.0': {}
 
   '@humanfs/core@0.19.1': {}
@@ -5858,7 +5806,7 @@ snapshots:
   '@jridgewell/gen-mapping@0.3.13':
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
-      '@jridgewell/trace-mapping': 0.3.31
+      '@jridgewell/trace-mapping': 0.3.25
 
   '@jridgewell/gen-mapping@0.3.8':
     dependencies:
@@ -5884,10 +5832,7 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.0
 
-  '@jridgewell/trace-mapping@0.3.31':
-    dependencies:
-      '@jridgewell/resolve-uri': 3.1.2
-      '@jridgewell/sourcemap-codec': 1.5.5
+  '@libav.js/variant-webcodecs@6.8.8': {}
 
   '@microsoft/api-extractor-model@7.31.0':
     dependencies:
@@ -6156,9 +6101,6 @@ snapshots:
   '@rollup/rollup-android-arm-eabi@4.41.0':
     optional: true
 
-  '@rollup/rollup-android-arm-eabi@4.52.3':
-    optional: true
-
   '@rollup/rollup-android-arm-eabi@4.55.1':
     optional: true
 
@@ -6168,9 +6110,6 @@ snapshots:
   '@rollup/rollup-android-arm64@4.41.0':
     optional: true
 
-  '@rollup/rollup-android-arm64@4.52.3':
-    optional: true
-
   '@rollup/rollup-android-arm64@4.55.1':
     optional: true
 
@@ -6180,9 +6119,6 @@ snapshots:
   '@rollup/rollup-darwin-arm64@4.41.0':
     optional: true
 
-  '@rollup/rollup-darwin-arm64@4.52.3':
-    optional: true
-
   '@rollup/rollup-darwin-arm64@4.55.1':
     optional: true
 
@@ -6192,9 +6128,6 @@ snapshots:
   '@rollup/rollup-darwin-x64@4.41.0':
     optional: true
 
-  '@rollup/rollup-darwin-x64@4.52.3':
-    optional: true
-
   '@rollup/rollup-darwin-x64@4.55.1':
     optional: true
 
@@ -6204,9 +6137,6 @@ snapshots:
   '@rollup/rollup-freebsd-arm64@4.41.0':
     optional: true
 
-  '@rollup/rollup-freebsd-arm64@4.52.3':
-    optional: true
-
   '@rollup/rollup-freebsd-arm64@4.55.1':
     optional: true
 
@@ -6216,9 +6146,6 @@ snapshots:
   '@rollup/rollup-freebsd-x64@4.41.0':
     optional: true
 
-  '@rollup/rollup-freebsd-x64@4.52.3':
-    optional: true
-
   '@rollup/rollup-freebsd-x64@4.55.1':
     optional: true
 
@@ -6228,9 +6155,6 @@ snapshots:
   '@rollup/rollup-linux-arm-gnueabihf@4.41.0':
     optional: true
 
-  '@rollup/rollup-linux-arm-gnueabihf@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-arm-gnueabihf@4.55.1':
     optional: true
 
@@ -6240,9 +6164,6 @@ snapshots:
   '@rollup/rollup-linux-arm-musleabihf@4.41.0':
     optional: true
 
-  '@rollup/rollup-linux-arm-musleabihf@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-arm-musleabihf@4.55.1':
     optional: true
 
@@ -6252,9 +6173,6 @@ snapshots:
   '@rollup/rollup-linux-arm64-gnu@4.41.0':
     optional: true
 
-  '@rollup/rollup-linux-arm64-gnu@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-arm64-gnu@4.55.1':
     optional: true
 
@@ -6264,15 +6182,9 @@ snapshots:
   '@rollup/rollup-linux-arm64-musl@4.41.0':
     optional: true
 
-  '@rollup/rollup-linux-arm64-musl@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-arm64-musl@4.55.1':
     optional: true
 
-  '@rollup/rollup-linux-loong64-gnu@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-loong64-gnu@4.55.1':
     optional: true
 
@@ -6291,9 +6203,6 @@ snapshots:
   '@rollup/rollup-linux-powerpc64le-gnu@4.41.0':
     optional: true
 
-  '@rollup/rollup-linux-ppc64-gnu@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-ppc64-gnu@4.55.1':
     optional: true
 
@@ -6306,18 +6215,12 @@ snapshots:
   '@rollup/rollup-linux-riscv64-gnu@4.41.0':
     optional: true
 
-  '@rollup/rollup-linux-riscv64-gnu@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-riscv64-gnu@4.55.1':
     optional: true
 
   '@rollup/rollup-linux-riscv64-musl@4.41.0':
     optional: true
 
-  '@rollup/rollup-linux-riscv64-musl@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-riscv64-musl@4.55.1':
     optional: true
 
@@ -6327,9 +6230,6 @@ snapshots:
   '@rollup/rollup-linux-s390x-gnu@4.41.0':
     optional: true
 
-  '@rollup/rollup-linux-s390x-gnu@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-s390x-gnu@4.55.1':
     optional: true
 
@@ -6339,9 +6239,6 @@ snapshots:
   '@rollup/rollup-linux-x64-gnu@4.41.0':
     optional: true
 
-  '@rollup/rollup-linux-x64-gnu@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-x64-gnu@4.55.1':
     optional: true
 
@@ -6351,18 +6248,12 @@ snapshots:
   '@rollup/rollup-linux-x64-musl@4.41.0':
     optional: true
 
-  '@rollup/rollup-linux-x64-musl@4.52.3':
-    optional: true
-
   '@rollup/rollup-linux-x64-musl@4.55.1':
     optional: true
 
   '@rollup/rollup-openbsd-x64@4.55.1':
     optional: true
 
-  '@rollup/rollup-openharmony-arm64@4.52.3':
-    optional: true
-
   '@rollup/rollup-openharmony-arm64@4.55.1':
     optional: true
 
@@ -6372,9 +6263,6 @@ snapshots:
   '@rollup/rollup-win32-arm64-msvc@4.41.0':
     optional: true
 
-  '@rollup/rollup-win32-arm64-msvc@4.52.3':
-    optional: true
-
   '@rollup/rollup-win32-arm64-msvc@4.55.1':
     optional: true
 
@@ -6384,15 +6272,9 @@ snapshots:
   '@rollup/rollup-win32-ia32-msvc@4.41.0':
     optional: true
 
-  '@rollup/rollup-win32-ia32-msvc@4.52.3':
-    optional: true
-
   '@rollup/rollup-win32-ia32-msvc@4.55.1':
     optional: true
 
-  '@rollup/rollup-win32-x64-gnu@4.52.3':
-    optional: true
-
   '@rollup/rollup-win32-x64-gnu@4.55.1':
     optional: true
 
@@ -6402,9 +6284,6 @@ snapshots:
   '@rollup/rollup-win32-x64-msvc@4.41.0':
     optional: true
 
-  '@rollup/rollup-win32-x64-msvc@4.52.3':
-    optional: true
-
   '@rollup/rollup-win32-x64-msvc@4.55.1':
     optional: true
 
@@ -6597,7 +6476,7 @@ snapshots:
       mrmime: 2.0.1
       sade: 1.8.1
       set-cookie-parser: 2.7.2
-      sirv: 3.0.2
+      sirv: 3.0.0
       svelte: 5.46.4
       vite: 7.3.1(@types/node@25.0.9)(jiti@1.21.7)(lightningcss@1.30.2)(sass@1.97.2)(tsx@4.19.4)(yaml@2.7.0)
     optionalDependencies:
@@ -6619,7 +6498,7 @@ snapshots:
       mrmime: 2.0.1
       sade: 1.8.1
       set-cookie-parser: 2.7.2
-      sirv: 3.0.2
+      sirv: 3.0.0
       svelte: 5.46.4
       vite: 7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass@1.97.2)(tsx@4.19.4)(yaml@2.7.0)
     optionalDependencies:
@@ -6739,6 +6618,12 @@ snapshots:
 
   '@types/cookie@0.6.0': {}
 
+  '@types/dom-mediacapture-transform@0.1.11':
+    dependencies:
+      '@types/dom-webcodecs': 0.1.13
+
+  '@types/dom-webcodecs@0.1.13': {}
+
   '@types/estree@1.0.6': {}
 
   '@types/estree@1.0.7': {}
@@ -6762,7 +6647,7 @@ snapshots:
 
   '@types/node-fetch@2.6.12':
     dependencies:
-      '@types/node': 25.0.9
+      '@types/node': 22.15.21
       form-data: 4.0.5
 
   '@types/node@22.10.7':
@@ -6781,6 +6666,8 @@ snapshots:
 
   '@types/triple-beam@1.3.2': {}
 
+  '@types/wicg-file-system-access@2023.10.7': {}
+
   '@typescript-eslint/eslint-plugin@8.25.0(@typescript-eslint/parser@8.25.0(eslint@9.21.0(jiti@2.6.1))(typescript@5.9.3))(eslint@9.21.0(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
       '@eslint-community/regexpp': 4.12.1
@@ -6819,7 +6706,7 @@ snapshots:
     dependencies:
       '@typescript-eslint/typescript-estree': 8.25.0(typescript@5.9.3)
       '@typescript-eslint/utils': 8.25.0(eslint@9.21.0(jiti@2.6.1))(typescript@5.9.3)
-      debug: 4.4.0
+      debug: 4.4.3
       eslint: 9.21.0(jiti@2.6.1)
       ts-api-utils: 2.0.1(typescript@5.9.3)
       typescript: 5.9.3
@@ -6858,6 +6745,16 @@ snapshots:
       '@typescript-eslint/types': 8.25.0
       eslint-visitor-keys: 4.2.0
 
+  '@wasm-audio-decoders/common@9.0.7':
+    dependencies:
+      '@eshaz/web-worker': 1.2.2
+      simple-yenc: 1.0.4
+
+  '@wasm-audio-decoders/flac@0.2.10':
+    dependencies:
+      '@wasm-audio-decoders/common': 9.0.7
+      codec-parser: 2.5.0
+
   abstract-logging@2.0.1: {}
 
   acorn-jsx@5.3.2(acorn@8.14.0):
@@ -7159,6 +7056,8 @@ snapshots:
 
   cluster-key-slot@1.1.2: {}
 
+  codec-parser@2.5.0: {}
+
   color-convert@1.9.3:
     dependencies:
       color-name: 1.1.3
@@ -8601,6 +8500,11 @@ snapshots:
 
   math-intrinsics@1.1.0: {}
 
+  mediabunny@1.27.2:
+    dependencies:
+      '@types/dom-mediacapture-transform': 0.1.11
+      '@types/dom-webcodecs': 0.1.13
+
   memoizee@0.4.17:
     dependencies:
       d: 1.0.2
@@ -8625,6 +8529,8 @@ snapshots:
     dependencies:
       mime-db: 1.52.0
 
+  mime@4.1.0: {}
+
   minimatch@10.0.3:
     dependencies:
       '@isaacs/brace-expansion': 5.0.0
@@ -8753,6 +8659,10 @@ snapshots:
       type-check: 0.4.0
       word-wrap: 1.2.5
 
+  opus-decoder@0.7.11:
+    dependencies:
+      '@wasm-audio-decoders/common': 9.0.7
+
   own-keys@1.0.1:
     dependencies:
       get-intrinsic: 1.2.7
@@ -9115,34 +9025,6 @@ snapshots:
       '@rollup/rollup-win32-x64-msvc': 4.41.0
       fsevents: 2.3.3
 
-  rollup@4.52.3:
-    dependencies:
-      '@types/estree': 1.0.8
-    optionalDependencies:
-      '@rollup/rollup-android-arm-eabi': 4.52.3
-      '@rollup/rollup-android-arm64': 4.52.3
-      '@rollup/rollup-darwin-arm64': 4.52.3
-      '@rollup/rollup-darwin-x64': 4.52.3
-      '@rollup/rollup-freebsd-arm64': 4.52.3
-      '@rollup/rollup-freebsd-x64': 4.52.3
-      '@rollup/rollup-linux-arm-gnueabihf': 4.52.3
-      '@rollup/rollup-linux-arm-musleabihf': 4.52.3
-      '@rollup/rollup-linux-arm64-gnu': 4.52.3
-      '@rollup/rollup-linux-arm64-musl': 4.52.3
-      '@rollup/rollup-linux-loong64-gnu': 4.52.3
-      '@rollup/rollup-linux-ppc64-gnu': 4.52.3
-      '@rollup/rollup-linux-riscv64-gnu': 4.52.3
-      '@rollup/rollup-linux-riscv64-musl': 4.52.3
-      '@rollup/rollup-linux-s390x-gnu': 4.52.3
-      '@rollup/rollup-linux-x64-gnu': 4.52.3
-      '@rollup/rollup-linux-x64-musl': 4.52.3
-      '@rollup/rollup-openharmony-arm64': 4.52.3
-      '@rollup/rollup-win32-arm64-msvc': 4.52.3
-      '@rollup/rollup-win32-ia32-msvc': 4.52.3
-      '@rollup/rollup-win32-x64-gnu': 4.52.3
-      '@rollup/rollup-win32-x64-msvc': 4.52.3
-      fsevents: 2.3.3
-
   rollup@4.55.1:
     dependencies:
       '@types/estree': 1.0.8
@@ -9371,7 +9253,9 @@ snapshots:
     dependencies:
       is-arrayish: 0.3.2
 
-  sirv@3.0.2:
+  simple-yenc@1.0.4: {}
+
+  sirv@3.0.0:
     dependencies:
       '@polka/url': 1.0.0-next.29
       mrmime: 2.0.1
@@ -9497,7 +9381,7 @@ snapshots:
 
   svelte-check@4.3.5(picomatch@4.0.3)(svelte@5.46.4)(typescript@5.9.3):
     dependencies:
-      '@jridgewell/trace-mapping': 0.3.31
+      '@jridgewell/trace-mapping': 0.3.25
       chokidar: 4.0.3
       fdir: 6.5.0(picomatch@4.0.3)
       picocolors: 1.1.1
@@ -9792,19 +9676,19 @@ snapshots:
       bundle-require: 5.1.0(esbuild@0.25.0)
       cac: 6.7.14
       chokidar: 4.0.3
-      consola: 3.4.2
-      debug: 4.4.3
+      consola: 3.4.0
+      debug: 4.4.0
       esbuild: 0.25.0
       fix-dts-default-cjs-exports: 1.0.1
       joycon: 3.1.1
       picocolors: 1.1.1
       postcss-load-config: 6.0.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.19.4)(yaml@2.7.0)
       resolve-from: 5.0.0
-      rollup: 4.52.3
+      rollup: 4.41.0
       source-map: 0.8.0-beta.0
       sucrase: 3.35.0
       tinyexec: 0.3.2
-      tinyglobby: 0.2.15
+      tinyglobby: 0.2.13
       tree-kill: 1.2.2
     optionalDependencies:
       '@microsoft/api-extractor': 7.53.0