From a067ac8e5d89f1a2c0ba7b92ea4251ddc6566af4 Mon Sep 17 00:00:00 2001
From: Snazzah <me@snazzah.com>
Date: Thu, 25 Dec 2025 22:02:40 +0000
Subject: [PATCH 1/6] feat(ferret): implement in-browser processing

---
 apps/ferret/package.json                      |   7 +
 apps/ferret/src/components/Checkbox.svelte    |   8 +-
 .../ferret/src/components/FormatButton.svelte |   9 +-
 apps/ferret/src/components/Modal.svelte       |  10 +-
 apps/ferret/src/lib/device.ts                 |  10 +
 apps/ferret/src/lib/minizel/bitstream.ts      |  78 +++
 apps/ferret/src/lib/minizel/index.ts          |   7 +
 .../src/lib/minizel/libav-flac-encoder.ts     | 154 +++++
 .../ferret/src/lib/minizel/mixed-processor.ts | 485 ++++++++++++++
 apps/ferret/src/lib/minizel/ogg.ts            |  83 +++
 .../src/lib/minizel/oggParser.worker.ts       | 152 +++++
 apps/ferret/src/lib/minizel/opus.ts           |  52 ++
 apps/ferret/src/lib/minizel/processor.ts      | 626 ++++++++++++++++++
 apps/ferret/src/lib/minizel/resilientFetch.ts | 163 +++++
 apps/ferret/src/lib/minizel/util.ts           |  97 +++
 apps/ferret/src/lib/recording/sections.ts     |  26 +-
 apps/ferret/src/lib/server/util.ts            |   2 +
 apps/ferret/src/lib/types.ts                  |   1 +
 .../[id=recording]/raw.dat/+server.ts         | 145 ++--
 .../rec/[id=recording]/DownloadSection.svelte |  57 +-
 .../rec/[id=recording]/MinizelModal.svelte    | 577 ++++++++++++++++
 apps/ferret/vite.config.ts                    |  55 +-
 locale                                        |   2 +-
 nginx.conf                                    |  16 +
 pnpm-lock.yaml                                | 109 ++-
 25 files changed, 2864 insertions(+), 67 deletions(-)
 create mode 100644 apps/ferret/src/lib/minizel/bitstream.ts
 create mode 100644 apps/ferret/src/lib/minizel/index.ts
 create mode 100644 apps/ferret/src/lib/minizel/libav-flac-encoder.ts
 create mode 100644 apps/ferret/src/lib/minizel/mixed-processor.ts
 create mode 100644 apps/ferret/src/lib/minizel/ogg.ts
 create mode 100644 apps/ferret/src/lib/minizel/oggParser.worker.ts
 create mode 100644 apps/ferret/src/lib/minizel/opus.ts
 create mode 100644 apps/ferret/src/lib/minizel/processor.ts
 create mode 100644 apps/ferret/src/lib/minizel/resilientFetch.ts
 create mode 100644 apps/ferret/src/lib/minizel/util.ts
 create mode 100644 apps/ferret/src/routes/rec/[id=recording]/MinizelModal.svelte

diff --git a/apps/ferret/package.json b/apps/ferret/package.json
index 237f85fe..c61c9cf9 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.8.0",
     "just-clone": "^6.2.0",
+    "mediabunny": "^1.21.1",
     "nanoid": "^5.1.6",
+    "opus-decoder": "^0.7.10",
     "zod": "^4.1.11"
   },
   "devDependencies": {
@@ -44,12 +49,14 @@
     "@sveltejs/enhanced-img": "^0.8.2",
     "@sveltejs/kit": "^2.21.1",
     "@sveltejs/vite-plugin-svelte": "^6.2.1",
+    "@types/wicg-file-system-access": "^2023.10.6",
     "autoprefixer": "^10.4.21",
     "clsx": "^2.1.1",
     "cookie-es": "^2.0.0",
     "discord-api-types": "^0.38.26",
     "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.93.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..347eb641 100644
--- a/apps/ferret/src/lib/device.ts
+++ b/apps/ferret/src/lib/device.ts
@@ -15,6 +15,11 @@ const device = {
     language: 'en',
     reducedMotion: false,
     reducedTransparency: false
+  },
+  capabilities: {
+    showSaveFilePicker: false,
+    showDirectoryPicker: false,
+    minizel: false
   }
 };
 
@@ -48,6 +53,11 @@ if (browser) {
     reducedMotion: window.matchMedia('(prefers-reduced-motion: reduce)').matches,
     reducedTransparency: window.matchMedia('(prefers-reduced-transparency: reduce)').matches
   };
+
+  // Detect File System Access API support for Minizel
+  device.capabilities.showSaveFilePicker = typeof window.showSaveFilePicker === 'function';
+  device.capabilities.showDirectoryPicker = typeof window.showDirectoryPicker === 'function';
+  device.capabilities.minizel = device.capabilities.showSaveFilePicker;
 }
 
 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..c16cc829
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/libav-flac-encoder.ts
@@ -0,0 +1,154 @@
+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'
+    });
+  }
+
+  #toS32(audioSample: AudioSample) {
+    const arrayBuffer = new ArrayBuffer(audioSample.allocationSize({ planeIndex: 0, format: 's32' }));
+    audioSample.copyTo(arrayBuffer, { planeIndex: 0, format: 's32' });
+    return new Int32Array(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_S32;
+    const raw = this.#toS32(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_S32,
+            bit_rate: 0,
+            sample_rate,
+            channel_layout,
+            channels: cc,
+            frame_size: 0
+          },
+          time_base: [1, sample_rate],
+          options: { strict: 'experimental' }
+        });
+
+        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..c9203923
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/mixed-processor.ts
@@ -0,0 +1,485 @@
+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;
+
+  // 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.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') {
+      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)) return;
+
+        // Packet far ahead: set position
+        if (currentPosition + 960n * 25n < granulePosition) chosenStartPosition = granulePosition;
+
+        // Decode
+        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();
+
+      // Wait for decoding to finish
+      await this.decodingQueue.done();
+      await this.opusDecoder?.free();
+      this.opusDecoder = null;
+      await this.flacDecoder?.free();
+      this.flacDecoder = null;
+
+      // Process remaining packets
+      await this.processMix(true);
+
+      // Finalize output
+      await this.queue.done();
+      await this.mbOutput!.finalize();
+
+      // 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..6ada84be
--- /dev/null
+++ b/apps/ferret/src/lib/minizel/processor.ts
@@ -0,0 +1,626 @@
+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();
+
+      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();
+          })
+        );
+    } 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..7d6e6d66 100644
--- a/apps/ferret/src/lib/recording/sections.ts
+++ b/apps/ferret/src/lib/recording/sections.ts
@@ -10,16 +10,23 @@ import fileIcon from '@iconify-icons/mdi/file';
 import textFileIcon from '@iconify-icons/mdi/file-text';
 
 import type { 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[];
   buttons: SectionButton[];
 }[];
 
+export type MinizelOptions = {
+  format: MinizelFormat;
+  mix?: boolean;
+};
+
 export type SectionButton = {
   text: Translatable;
   suffix?: string;
@@ -30,6 +37,7 @@ export type SectionButton = {
     container?: Kitchen.ContainerType;
   };
   ennuizel?: number;
+  minizel?: MinizelOptions;
   allowNorm?: boolean;
   noIgnore?: boolean;
   showFor?: DevicePlatform[];
@@ -58,7 +66,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 +84,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 +99,20 @@ export const audioButtons: SectionButtons = [
       { icon: mp3Icon, text: 'MP3', options: { format: 'mp3', container: 'mix' }, features: ['mp3'] }
     ]
   },
+  {
+    title: { t: 'download.sections.minizel' },
+    beta: true,
+    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 f7bb4efc..efd51b31 100644
--- a/apps/ferret/src/lib/server/util.ts
+++ b/apps/ferret/src/lib/server/util.ts
@@ -197,6 +197,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 060414c7..b3c1d4b2 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/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 05448169..c99d6db9 100644
--- a/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
+++ b/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
@@ -9,6 +9,7 @@
   import FormatButton from '$components/FormatButton.svelte';
   import RequiresTier from '$components/RequiresTier.svelte';
   import { device } 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';
@@ -17,6 +18,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 {
@@ -35,12 +37,23 @@
   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;
+  }
 </script>
 
 {#if noUsers}
@@ -72,19 +85,31 @@
         {@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}
+        {@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 minizelAvailable = isMinizelButtonAvailable(button)}
+                {#if featureAvailable && (available || audioShowHidden || minizelAvailable)}
                   <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 };
+                      else onButtonClick(button, section.title);
+                    }}
                   >
                     {convertT(button.text, $t)}
                   </FormatButton>
@@ -182,3 +207,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..027bf57b
--- /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() {
+    const now = performance.now();
+    if (!processor) return;
+
+    // Throttle UI updates
+    if (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();
+      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/locale b/locale
index 4d3224e5..ffe6b13f 160000
--- a/locale
+++ b/locale
@@ -1 +1 @@
-Subproject commit 4d3224e56314989b9fe1f602eaaa32d7eccd30b6
+Subproject commit ffe6b13fd6afc1746a013cb04eea286a4e30c62d
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 1ef47bcb..c732cab5 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.1.11
         version: 4.1.11
@@ -310,6 +325,9 @@ importers:
       '@sveltejs/vite-plugin-svelte':
         specifier: ^6.2.1
         version: 6.2.1(svelte@5.39.6)(vite@7.1.7(@types/node@22.15.21)(jiti@2.6.0)(lightningcss@1.30.1)(sass@1.93.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.21
         version: 10.4.21(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
@@ -843,6 +864,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}
@@ -919,6 +943,9 @@ packages:
   '@formatjs/intl-localematcher@0.5.10':
     resolution: {integrity: sha512-af3qATX+m4Rnd9+wHcjJ4w2ijq+rAVP3CCinJQvFv1kgSu1W6jypUmvleJxcewdxmutM8dmIRZFxO/IQBZmP2Q==}
 
+  '@henrygd/queue@1.2.0':
+    resolution: {integrity: sha512-jW/BLSTpcvExDhqJGxtIPgGr2O0IFF8XUNDwEbfCfhrXT8a4xztQ9Lv6U/vbYzYC0xVWn+3zv6YnLUh3bEFUKA==}
+
   '@henrygd/semaphore@0.1.0':
     resolution: {integrity: sha512-5wRPsfP9iWnOTFRd7QKdHlWTgY9xw9GAHSkQP/Q05ZTKUBdfTj44BhsnADPfvBoUQVGDtP2Nd0UShVdeTLuLwA==}
 
@@ -1139,6 +1166,9 @@ packages:
   '@jridgewell/trace-mapping@0.3.25':
     resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==}
 
+  '@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==}
 
@@ -1834,6 +1864,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==}
 
@@ -1876,6 +1912,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}
@@ -1923,6 +1962,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==}
 
@@ -2186,6 +2231,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==}
 
@@ -3427,6 +3475,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'}
@@ -3447,6 +3498,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}
@@ -3588,6 +3644,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'}
@@ -4170,6 +4229,9 @@ packages:
   simple-swizzle@0.2.2:
     resolution: {integrity: sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==}
 
+  simple-yenc@1.0.4:
+    resolution: {integrity: sha512-5gvxpSd79e9a3V4QDYUqnqxeD4HGlhCakVpb6gMnDD7lexJggSBJRBO5h52y/iJrdXRilX9UCuDaIJhSWm5OWw==}
+
   sirv@3.0.0:
     resolution: {integrity: sha512-BPwJGUeDaDCHihkORDchNyyTvWFhcusy1XMmhEVTQTwGeybFbp8YEmB+njbPnth1FibULBSBVwCQni25XlCUDg==}
     engines: {node: '>=18'}
@@ -4944,6 +5006,8 @@ snapshots:
   '@esbuild/win32-x64@0.25.0':
     optional: true
 
+  '@eshaz/web-worker@1.2.2': {}
+
   '@eslint-community/eslint-utils@4.4.1(eslint@9.21.0(jiti@2.6.0))':
     dependencies:
       eslint: 9.21.0(jiti@2.6.0)
@@ -5043,6 +5107,8 @@ snapshots:
     dependencies:
       tslib: 2.8.1
 
+  '@henrygd/queue@1.2.0': {}
+
   '@henrygd/semaphore@0.1.0': {}
 
   '@humanfs/core@0.19.1': {}
@@ -5231,6 +5297,8 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.0
 
+  '@libav.js/variant-webcodecs@6.8.8': {}
+
   '@microsoft/api-extractor-model@7.31.0':
     dependencies:
       '@microsoft/tsdoc': 0.15.1
@@ -5942,6 +6010,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': {}
@@ -5980,6 +6054,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.0))(typescript@5.9.2))(eslint@9.21.0(jiti@2.6.0))(typescript@5.9.2)':
     dependencies:
       '@eslint-community/regexpp': 4.12.1
@@ -6057,6 +6133,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):
@@ -6354,6 +6440,8 @@ snapshots:
 
   cluster-key-slot@1.1.2: {}
 
+  codec-parser@2.5.0: {}
+
   color-convert@1.9.3:
     dependencies:
       color-name: 1.1.3
@@ -7756,6 +7844,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
@@ -7780,6 +7873,8 @@ snapshots:
     dependencies:
       mime-db: 1.52.0
 
+  mime@4.1.0: {}
+
   minimatch@10.0.3:
     dependencies:
       '@isaacs/brace-expansion': 5.0.0
@@ -7912,6 +8007,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
@@ -8455,6 +8554,8 @@ snapshots:
     dependencies:
       is-arrayish: 0.3.2
 
+  simple-yenc@1.0.4: {}
+
   sirv@3.0.0:
     dependencies:
       '@polka/url': 1.0.0-next.28
@@ -8872,19 +8973,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.0)(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

From f34ab55f137aab3a3ccfb2d3b26a4e5dd40393ef Mon Sep 17 00:00:00 2001
From: Snazzah <me@snazzah.com>
Date: Thu, 25 Dec 2025 22:39:18 +0000
Subject: [PATCH 2/6] fix(ferret): set flac to have 16 bitdepth

---
 .../src/lib/minizel/libav-flac-encoder.ts       | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/apps/ferret/src/lib/minizel/libav-flac-encoder.ts b/apps/ferret/src/lib/minizel/libav-flac-encoder.ts
index c16cc829..72059a14 100644
--- a/apps/ferret/src/lib/minizel/libav-flac-encoder.ts
+++ b/apps/ferret/src/lib/minizel/libav-flac-encoder.ts
@@ -25,10 +25,10 @@ export class LibAVFlacEncoder extends CustomAudioEncoder {
     });
   }
 
-  #toS32(audioSample: AudioSample) {
-    const arrayBuffer = new ArrayBuffer(audioSample.allocationSize({ planeIndex: 0, format: 's32' }));
-    audioSample.copyTo(arrayBuffer, { planeIndex: 0, format: 's32' });
-    return new Int32Array(arrayBuffer);
+  #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) {
@@ -62,8 +62,8 @@ export class LibAVFlacEncoder extends CustomAudioEncoder {
   async encode(audioSample: AudioSample) {
     if (!this._libav) throw new TypeError('No LibAV');
 
-    const format = LibAV.AV_SAMPLE_FMT_S32;
-    const raw = this.#toS32(audioSample);
+    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
@@ -90,15 +90,14 @@ export class LibAVFlacEncoder extends CustomAudioEncoder {
       if (!this._c) {
         const [, c, frame, pkt] = await this._libav.ff_init_encoder('flac', {
           ctx: {
-            sample_fmt: LibAV.AV_SAMPLE_FMT_S32,
+            sample_fmt: LibAV.AV_SAMPLE_FMT_S16,
             bit_rate: 0,
             sample_rate,
             channel_layout,
             channels: cc,
             frame_size: 0
           },
-          time_base: [1, sample_rate],
-          options: { strict: 'experimental' }
+          time_base: [1, sample_rate]
         });
 
         this._c = c;

From 1f8acf33a5339d7b873b121537bff734914dd488 Mon Sep 17 00:00:00 2001
From: Snazzah <me@snazzah.com>
Date: Fri, 26 Dec 2025 01:18:54 +0000
Subject: [PATCH 3/6] fix(ferret): make device object reactive and fix firefox
 things

---
 apps/ferret/src/lib/device.ts                 | 99 ++++++++++++++-----
 apps/ferret/src/lib/recording/sections.ts     |  4 +-
 apps/ferret/src/routes/+layout.ts             |  5 +-
 .../rec/[id=recording]/DownloadSection.svelte | 23 +++--
 4 files changed, 92 insertions(+), 39 deletions(-)

diff --git a/apps/ferret/src/lib/device.ts b/apps/ferret/src/lib/device.ts
index 347eb641..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,
@@ -23,41 +47,64 @@ const device = {
   }
 };
 
-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,
-
-    iphone,
-    android,
-
-    mobile: iphone || android,
-    desktop: !(iphone || android)
-  };
+  const firefox = ua.includes('firefox');
 
-  device.userAgent = userAgent;
+  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
+    }
+  }));
 }
 
-if (browser) {
-  processUserAgent(navigator.userAgent.toLowerCase());
+/** Refresh device capabilities - call once after mount to ensure reactivity */
+export function refreshDeviceCapabilities() {
+  if (!browser) return;
 
-  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
-  };
+  device.update((d) => {
+    const hasShowSaveFilePicker = typeof window.showSaveFilePicker === 'function';
+    const hasShowDirectoryPicker = typeof window.showDirectoryPicker === 'function';
 
-  // Detect File System Access API support for Minizel
-  device.capabilities.showSaveFilePicker = typeof window.showSaveFilePicker === 'function';
-  device.capabilities.showDirectoryPicker = typeof window.showDirectoryPicker === 'function';
-  device.capabilities.minizel = device.capabilities.showSaveFilePicker;
+    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
+      }
+    };
+  });
 }
 
-export { device };
+if (browser) {
+  processUserAgent(navigator.userAgent);
+  refreshDeviceCapabilities();
+}
diff --git a/apps/ferret/src/lib/recording/sections.ts b/apps/ferret/src/lib/recording/sections.ts
index 7d6e6d66..af704ed3 100644
--- a/apps/ferret/src/lib/recording/sections.ts
+++ b/apps/ferret/src/lib/recording/sections.ts
@@ -9,7 +9,7 @@ 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';
@@ -19,6 +19,7 @@ export type SectionButtons = {
   beta?: boolean;
   features?: MinimalRecordingInfo['features'];
   showFor?: DevicePlatform[];
+  capabilities?: DeviceCapability[];
   buttons: SectionButton[];
 }[];
 
@@ -102,6 +103,7 @@ export const audioButtons: SectionButtons = [
   {
     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 },
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/rec/[id=recording]/DownloadSection.svelte b/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
index c99d6db9..3831d9d4 100644
--- a/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
+++ b/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
@@ -2,13 +2,14 @@
   import Icon from '@iconify/svelte';
   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';
@@ -50,10 +51,12 @@
 
   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;
+    if (!$device.capabilities.minizel) return false;
+    if (button.minizel.mix) return $device.capabilities.showSaveFilePicker;
+    return $device.capabilities.showDirectoryPicker;
   }
+
+  onMount(() => refreshDeviceCapabilities());
 </script>
 
 {#if noUsers}
@@ -84,9 +87,10 @@
       {#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))}
+          (!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}
+        {@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">
@@ -98,9 +102,8 @@
             <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)}
-                {@const minizelAvailable = isMinizelButtonAvailable(button)}
-                {#if featureAvailable && (available || audioShowHidden || minizelAvailable)}
+                {@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}
@@ -130,7 +133,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}

From a72ce8656fa94199cbaf5480f0a27b725ecb7277 Mon Sep 17 00:00:00 2001
From: Snazzah <me@snazzah.com>
Date: Tue, 30 Dec 2025 22:44:48 +0000
Subject: [PATCH 4/6] feat(ferret): track minizel usage

---
 .../src/routes/rec/[id=recording]/DownloadSection.svelte | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte b/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
index 3831d9d4..0e2c4e09 100644
--- a/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
+++ b/apps/ferret/src/routes/rec/[id=recording]/DownloadSection.svelte
@@ -110,8 +110,13 @@
                     suffix={button.suffix}
                     icon={button.icon}
                     onclick={() => {
-                      if (button.minizel) minizelModal = { format: button.minizel.format, mix: button.minizel.mix ?? false };
-                      else onButtonClick(button, section.title);
+                      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)}

From 2f360795398e5af6cc13c640ab702034e4e175a2 Mon Sep 17 00:00:00 2001
From: Snazzah <me@snazzah.com>
Date: Tue, 30 Dec 2025 23:00:05 +0000
Subject: [PATCH 5/6] chore: some logging

---
 .../ferret/src/lib/minizel/mixed-processor.ts | 29 ++++++++++++++++++-
 apps/ferret/src/lib/minizel/processor.ts      | 10 +++++++
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/apps/ferret/src/lib/minizel/mixed-processor.ts b/apps/ferret/src/lib/minizel/mixed-processor.ts
index c9203923..768890de 100644
--- a/apps/ferret/src/lib/minizel/mixed-processor.ts
+++ b/apps/ferret/src/lib/minizel/mixed-processor.ts
@@ -88,6 +88,9 @@ export class MixedProcessor {
   downloadedBytes = 0;
   bytesWritten = 0;
   currentMixPosition = 0;
+  samplesWritten = 0;
+  packetsDecoded = 0;
+  pagesReceived = 0;
 
   // Decoders
   private opusDecoder: OpusDecoderWebWorker<48000> | null = null;
@@ -199,6 +202,7 @@ export class MixedProcessor {
 
   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);
@@ -309,6 +313,7 @@ export class MixedProcessor {
     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);
@@ -355,12 +360,16 @@ export class MixedProcessor {
         let chosenStartPosition = currentPosition;
 
         // Packet far behind: drop
-        if (currentPosition > granulePosition + BigInt(960 * 25)) return;
+        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;
 
@@ -451,20 +460,38 @@ export class MixedProcessor {
       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}`);
+
+      // Check for empty output
+      // if (this.bytesWritten === 0 && this.packetsDecoded === 0) {
+      //   throw new Error('No audio data was found in the recording');
+      // }
+      // if (this.bytesWritten === 0 && this.samplesWritten === 0) {
+      //   throw new Error(`No audio samples were written (decoded ${this.packetsDecoded} packets but mix cache was empty)`);
+      // }
+
       // Final progress update
       this.onProgress?.();
       this.onFinish?.();
diff --git a/apps/ferret/src/lib/minizel/processor.ts b/apps/ferret/src/lib/minizel/processor.ts
index 6ada84be..d7bdd9e6 100644
--- a/apps/ferret/src/lib/minizel/processor.ts
+++ b/apps/ferret/src/lib/minizel/processor.ts
@@ -590,6 +590,8 @@ export class MinizelProcessor {
       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]) => {
@@ -605,6 +607,14 @@ export class MinizelProcessor {
             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();

From 14387ab29d7cb5914559c4697d36ce6e1dc72af0 Mon Sep 17 00:00:00 2001
From: Snazzah <me@snazzah.com>
Date: Tue, 30 Dec 2025 23:05:45 +0000
Subject: [PATCH 6/6] chore: fix ui updates

---
 apps/ferret/src/lib/minizel/mixed-processor.ts            | 8 --------
 .../src/routes/rec/[id=recording]/MinizelModal.svelte     | 8 ++++----
 2 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/apps/ferret/src/lib/minizel/mixed-processor.ts b/apps/ferret/src/lib/minizel/mixed-processor.ts
index 768890de..01cfc790 100644
--- a/apps/ferret/src/lib/minizel/mixed-processor.ts
+++ b/apps/ferret/src/lib/minizel/mixed-processor.ts
@@ -484,14 +484,6 @@ export class MixedProcessor {
 
       console.debug(`[Minizel] Output finalized. Bytes written: ${this.bytesWritten}`);
 
-      // Check for empty output
-      // if (this.bytesWritten === 0 && this.packetsDecoded === 0) {
-      //   throw new Error('No audio data was found in the recording');
-      // }
-      // if (this.bytesWritten === 0 && this.samplesWritten === 0) {
-      //   throw new Error(`No audio samples were written (decoded ${this.packetsDecoded} packets but mix cache was empty)`);
-      // }
-
       // Final progress update
       this.onProgress?.();
       this.onFinish?.();
diff --git a/apps/ferret/src/routes/rec/[id=recording]/MinizelModal.svelte b/apps/ferret/src/routes/rec/[id=recording]/MinizelModal.svelte
index 027bf57b..b133fbb5 100644
--- a/apps/ferret/src/routes/rec/[id=recording]/MinizelModal.svelte
+++ b/apps/ferret/src/routes/rec/[id=recording]/MinizelModal.svelte
@@ -113,12 +113,12 @@
     return users.length > 0 && excludedTracks.size === users.length;
   }
 
-  function updateStats() {
+  function updateStats(force = false) {
     const now = performance.now();
     if (!processor) return;
 
-    // Throttle UI updates
-    if (now - lastUIUpdateTime < UI_UPDATE_INTERVAL_MS) return;
+    // Throttle UI updates (unless forced)
+    if (!force && now - lastUIUpdateTime < UI_UPDATE_INTERVAL_MS) return;
     lastUIUpdateTime = now;
 
     const prevDownloaded = downloadedBytes;
@@ -260,7 +260,7 @@
         await multiProcessor.start();
       }
 
-      updateStats();
+      updateStats(true); // Force final stats update
       processState = 'complete';
     } catch (e) {
       if (e instanceof Error && e.name === 'AbortError') {