diff --git a/.claude/launch.json b/.claude/launch.json
index 34c8c2caa2..d6ae306d38 100644
--- a/.claude/launch.json
+++ b/.claude/launch.json
@@ -20,12 +20,6 @@
       "runtimeExecutable": "node",
       "runtimeArgs": ["node_modules/vite/bin/vite.js", "--config", "vite.v4preview.config.ts"],
       "port": 5207
-    },
-    {
-      "name": "poc",
-      "runtimeExecutable": "npx",
-      "runtimeArgs": ["vite", "--config", "poc/vite.config.js"],
-      "port": 5210
     }
   ]
 }
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 33fba48069..8ba60c0cf2 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -38,12 +38,6 @@ jobs:
       - name: Setup Node.js
         uses: ./.github/actions/setup
 
-      - name: Cache caption assets
-        uses: actions/cache@v4
-        with:
-          path: caption-assets
-          key: caption-assets-${{ runner.os }}-${{ hashFiles('scripts/fetch-caption-model.mjs') }}
-
       # ponytail: STT is handled by the bundled whisper-stt-server (whisper.cpp
       # with native DTW token timestamps). No separate VAD model is fetched
       # here. See technical-documentation/architecture/transcription-and-captions.md for the full architecture.
@@ -69,12 +63,6 @@ jobs:
       - name: Setup Node.js
         uses: ./.github/actions/setup
 
-      - name: Cache caption assets
-        uses: actions/cache@v4
-        with:
-          path: caption-assets
-          key: caption-assets-${{ runner.os }}-${{ hashFiles('scripts/fetch-caption-model.mjs') }}
-
       # ponytail: STT is handled by the bundled whisper-stt-server (whisper.cpp
       # with native DTW token timestamps). No separate VAD model is fetched
       # here. See technical-documentation/architecture/transcription-and-captions.md for the full architecture.
@@ -114,12 +102,6 @@ jobs:
         env:
           npm_config_build_from_source: "false"
 
-      - name: Cache caption assets
-        uses: actions/cache@v4
-        with:
-          path: caption-assets
-          key: caption-assets-${{ runner.os }}-${{ hashFiles('scripts/fetch-caption-model.mjs') }}
-
       # ponytail: STT is handled by the bundled whisper-stt-server (see the
       # build-windows comment); no VAD model is fetched here.
       - name: Resolve macOS signing
@@ -279,12 +261,6 @@ jobs:
       - name: Install pacman build dependencies
         run: sudo apt-get update && sudo apt-get install -y libarchive-tools
 
-      - name: Cache caption assets
-        uses: actions/cache@v4
-        with:
-          path: caption-assets
-          key: caption-assets-${{ runner.os }}-${{ hashFiles('scripts/fetch-caption-model.mjs') }}
-
       # ponytail: no VAD fetch here either (see build-windows comment).
       - name: Build Linux app
         run: npm run build:linux -- --publish never
diff --git a/design/_adherence.oxlintrc.json b/design/_adherence.oxlintrc.json
deleted file mode 100644
index 62081bd579..0000000000
--- a/design/_adherence.oxlintrc.json
+++ /dev/null
@@ -1,511 +0,0 @@
-{
-  "plugins": [
-    "react",
-    "import"
-  ],
-  "rules": {
-    "react/forbid-elements": [
-      "warn",
-      {
-        "forbid": []
-      }
-    ],
-    "no-restricted-imports": [
-      "warn",
-      {
-        "patterns": [
-          {
-            "group": [
-              "components/display/**",
-              "components/editor/**",
-              "components/forms/**"
-            ],
-            "message": "Import design-system components from 'index.js', not component internals."
-          }
-        ]
-      }
-    ],
-    "no-restricted-syntax": [
-      "warn",
-      {
-        "selector": "Literal[value=/#[0-9a-fA-F]{3,8}\\b/]",
-        "message": "Raw hex color — use a design-system color token via var()."
-      },
-      {
-        "selector": "Literal[value=/\\b\\d+px\\b/]",
-        "message": "Raw px value — use a design-system spacing token via var()."
-      },
-      {
-        "selector": "Literal[value=/font-family\\s*:\\s*(?!['\\\"]?(?:Geist|Geist Mono|Inter|IBM Plex Mono|Fira Code|Caveat|Permanent Marker|Bebas Neue|Oswald|Space Grotesk|Playfair Display))/i]",
-        "message": "Font not provided by the design system. Available: Geist, Geist Mono, Inter, IBM Plex Mono, Fira Code, Caveat, Permanent Marker, Bebas Neue, Oswald, Space Grotesk, Playfair Display."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='Badge'] > JSXAttribute > JSXIdentifier[name!=/^(?:children|tone|dot|soft|mono|style|key|ref|className|style|children)$/]",
-        "message": "<Badge> doesn't accept that prop. Declared props: children, tone, dot, soft, mono, style."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='Badge'] > JSXAttribute[name.name='tone'] > Literal[value!=/^(?:accent|neutral|danger|warn)$/]",
-        "message": "<Badge> tone must be one of 'accent' | 'neutral' | 'danger' | 'warn'."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='Button'] > JSXAttribute > JSXIdentifier[name!=/^(?:variant|size|icon|iconRight|disabled|fullWidth|onClick|children|style|key|ref|className|style|children)$/]",
-        "message": "<Button> doesn't accept that prop. Declared props: variant, size, icon, iconRight, disabled, fullWidth, onClick, children, style."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='Button'] > JSXAttribute[name.name='variant'] > Literal[value!=/^(?:primary|secondary|ghost)$/]",
-        "message": "<Button> variant must be one of 'primary' | 'secondary' | 'ghost'."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='Button'] > JSXAttribute[name.name='size'] > Literal[value!=/^(?:sm|md|lg)$/]",
-        "message": "<Button> size must be one of 'sm' | 'md' | 'lg'."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='Card'] > JSXAttribute > JSXIdentifier[name!=/^(?:children|title|headerRight|elevation|level|radius|padding|style|bodyStyle|key|ref|className|style|children)$/]",
-        "message": "<Card> doesn't accept that prop. Declared props: children, title, headerRight, elevation, level, radius, padding, style, bodyStyle."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='Card'] > JSXAttribute[name.name='elevation'] > Literal[value!=/^(?:card|pop)$/]",
-        "message": "<Card> elevation must be one of 'card' | 'pop'."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='ChatBubble'] > JSXAttribute > JSXIdentifier[name!=/^(?:role|author|time|avatar|children|key|ref|className|style|children)$/]",
-        "message": "<ChatBubble> doesn't accept that prop. Declared props: role, author, time, avatar, children."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='ChatBubble'] > JSXAttribute[name.name='role'] > Literal[value!=/^(?:assistant|user|system)$/]",
-        "message": "<ChatBubble> role must be one of 'assistant' | 'user' | 'system'."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='Chip'] > JSXAttribute > JSXIdentifier[name!=/^(?:children|icon|onClick|style|key|ref|className|style|children)$/]",
-        "message": "<Chip> doesn't accept that prop. Declared props: children, icon, onClick, style."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='FacetRailButton'] > JSXAttribute > JSXIdentifier[name!=/^(?:active|title|onClick|children|style|key|ref|className|style|children)$/]",
-        "message": "<FacetRailButton> doesn't accept that prop. Declared props: active, title, onClick, children, style."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='IconButton'] > JSXAttribute > JSXIdentifier[name!=/^(?:size|active|tone|disabled|title|onClick|children|style|key|ref|className|style|children)$/]",
-        "message": "<IconButton> doesn't accept that prop. Declared props: size, active, tone, disabled, title, onClick, children, style."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='IconButton'] > JSXAttribute[name.name='tone'] > Literal[value!=/^(?:default|danger)$/]",
-        "message": "<IconButton> tone must be one of 'default' | 'danger'."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='MediaCard'] > JSXAttribute > JSXIdentifier[name!=/^(?:name|duration|size|from|to|selected|draggable|onClick|onDragStart|onDragEnd|style|key|ref|className|style|children)$/]",
-        "message": "<MediaCard> doesn't accept that prop. Declared props: name, duration, size, from, to, selected, draggable, onClick, onDragStart, onDragEnd, style."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='ProgressBar'] > JSXAttribute > JSXIdentifier[name!=/^(?:value|height|gradient|style|key|ref|className|style|children)$/]",
-        "message": "<ProgressBar> doesn't accept that prop. Declared props: value, height, gradient, style."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='ProposalItem'] > JSXAttribute > JSXIdentifier[name!=/^(?:range|dur|key|ref|className|style|children)$/]",
-        "message": "<ProposalItem> doesn't accept that prop. Declared props: range, dur."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='SegmentOption'] > JSXAttribute > JSXIdentifier[name!=/^(?:value|label|key|ref|className|style|children)$/]",
-        "message": "<SegmentOption> doesn't accept that prop. Declared props: value, label."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='SelectOption'] > JSXAttribute > JSXIdentifier[name!=/^(?:value|label|key|ref|className|style|children)$/]",
-        "message": "<SelectOption> doesn't accept that prop. Declared props: value, label."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='Slider'] > JSXAttribute > JSXIdentifier[name!=/^(?:label|value|min|max|step|format|onChange|card|style|key|ref|className|style|children)$/]",
-        "message": "<Slider> doesn't accept that prop. Declared props: label, value, min, max, step, format, onChange, card, style."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='Switch'] > JSXAttribute > JSXIdentifier[name!=/^(?:checked|onChange|disabled|style|key|ref|className|style|children)$/]",
-        "message": "<Switch> doesn't accept that prop. Declared props: checked, onChange, disabled, style."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='TextField'] > JSXAttribute > JSXIdentifier[name!=/^(?:value|onChange|placeholder|multiline|leadingIcon|rows|style|wrapStyle|key|ref|className|style|children)$/]",
-        "message": "<TextField> doesn't accept that prop. Declared props: value, onChange, placeholder, multiline, leadingIcon, rows, style, wrapStyle."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='TimelinePill'] > JSXAttribute > JSXIdentifier[name!=/^(?:tone|icon|children|leftPct|widthPct|style|key|ref|className|style|children)$/]",
-        "message": "<TimelinePill> doesn't accept that prop. Declared props: tone, icon, children, leftPct, widthPct, style."
-      },
-      {
-        "selector": "JSXOpeningElement[name.name='TimelinePill'] > JSXAttribute[name.name='tone'] > Literal[value!=/^(?:accent|annotation|speed|danger)$/]",
-        "message": "<TimelinePill> tone must be one of 'accent' | 'annotation' | 'speed' | 'danger'."
-      }
-    ]
-  },
-  "overrides": [
-    {
-      "files": [
-        "**/index.js"
-      ],
-      "rules": {
-        "no-restricted-imports": "off"
-      }
-    }
-  ],
-  "x-omelette": {
-    "components": {
-      "Badge": {
-        "replaces": []
-      },
-      "Button": {
-        "replaces": []
-      },
-      "Card": {
-        "replaces": []
-      },
-      "ChatBubble": {
-        "replaces": []
-      },
-      "Chip": {
-        "replaces": []
-      },
-      "FacetRailButton": {
-        "replaces": []
-      },
-      "IconButton": {
-        "replaces": []
-      },
-      "MediaCard": {
-        "replaces": []
-      },
-      "ProgressBar": {
-        "replaces": []
-      },
-      "ProposalItem": {
-        "replaces": []
-      },
-      "SegmentOption": {
-        "replaces": []
-      },
-      "SelectOption": {
-        "replaces": []
-      },
-      "Slider": {
-        "replaces": []
-      },
-      "Switch": {
-        "replaces": []
-      },
-      "TextField": {
-        "replaces": []
-      },
-      "TimelinePill": {
-        "replaces": []
-      }
-    },
-    "tokens": [
-      "--accent",
-      "--accent-foreground",
-      "--accent-primary",
-      "--background",
-      "--border",
-      "--border-default",
-      "--brand-green",
-      "--brand-green-active",
-      "--brand-green-glow",
-      "--brand-green-hover",
-      "--brand-green-ring",
-      "--brand-green-tint",
-      "--card",
-      "--card-foreground",
-      "--color-bg",
-      "--color-fg",
-      "--control-h-lg",
-      "--control-h-md",
-      "--control-h-sm",
-      "--control-h-xs",
-      "--destructive",
-      "--destructive-foreground",
-      "--dur",
-      "--dur-base",
-      "--dur-fast",
-      "--dur-mid",
-      "--dur-slow",
-      "--ease",
-      "--elev-card",
-      "--elev-pop",
-      "--fill",
-      "--fill-hover",
-      "--fill-subtle",
-      "--focus-ring",
-      "--font-caption-grotesk",
-      "--font-caption-hand",
-      "--font-caption-impact",
-      "--font-caption-marker",
-      "--font-caption-serif",
-      "--font-mono",
-      "--font-sans",
-      "--foreground",
-      "--fw-bold",
-      "--fw-medium",
-      "--fw-regular",
-      "--fw-semibold",
-      "--glass-blur",
-      "--glass-blur-strong",
-      "--glass-hud",
-      "--glass-popover",
-      "--glass-shell",
-      "--glow-accent",
-      "--gradient-panel",
-      "--gradient-selected",
-      "--gradient-workspace",
-      "--icon-lg",
-      "--icon-md",
-      "--icon-sm",
-      "--icon-xs",
-      "--input",
-      "--lh-none",
-      "--lh-normal",
-      "--lh-relaxed",
-      "--lh-snug",
-      "--lh-tight",
-      "--line",
-      "--line-strong",
-      "--line-subtle",
-      "--muted",
-      "--muted-foreground",
-      "--popover",
-      "--popover-foreground",
-      "--press-scale",
-      "--primary",
-      "--primary-foreground",
-      "--radius",
-      "--radius-2xl",
-      "--radius-3xl",
-      "--radius-full",
-      "--radius-lg",
-      "--radius-md",
-      "--radius-pill",
-      "--radius-sm",
-      "--radius-window",
-      "--radius-xl",
-      "--radius-xs",
-      "--rail-width",
-      "--rec-amber",
-      "--rec-amber-text",
-      "--rec-red",
-      "--rec-red-text",
-      "--ring",
-      "--ring-focus",
-      "--ring-slider",
-      "--secondary",
-      "--secondary-foreground",
-      "--shadow-badge",
-      "--shadow-capture",
-      "--shadow-card",
-      "--shadow-card-hover",
-      "--shadow-hud",
-      "--shadow-inset-hi",
-      "--shadow-panel",
-      "--shadow-popover",
-      "--shell-0",
-      "--shell-1",
-      "--shell-2",
-      "--shell-3",
-      "--shell-4",
-      "--shell-5",
-      "--space-0",
-      "--space-0-5",
-      "--space-1",
-      "--space-1-5",
-      "--space-10",
-      "--space-12",
-      "--space-2",
-      "--space-2-5",
-      "--space-3",
-      "--space-3-5",
-      "--space-4",
-      "--space-5",
-      "--space-6",
-      "--space-8",
-      "--surface-card",
-      "--surface-popover",
-      "--text-1",
-      "--text-10",
-      "--text-11",
-      "--text-12",
-      "--text-13",
-      "--text-2",
-      "--text-2xl",
-      "--text-3",
-      "--text-4",
-      "--text-5",
-      "--text-9",
-      "--text-base",
-      "--text-body",
-      "--text-hi",
-      "--text-lg",
-      "--text-muted",
-      "--text-slate-500",
-      "--text-sm",
-      "--text-xl",
-      "--tracking-normal",
-      "--tracking-tight",
-      "--workspace-pad"
-    ],
-    "tokenKinds": {
-      "--ease": "other",
-      "--dur": "other",
-      "--brand-green": "color",
-      "--brand-green-hover": "color",
-      "--brand-green-active": "color",
-      "--brand-green-ring": "color",
-      "--brand-green-glow": "color",
-      "--brand-green-tint": "color",
-      "--rec-red": "color",
-      "--rec-red-text": "font",
-      "--rec-amber": "color",
-      "--rec-amber-text": "font",
-      "--background": "other",
-      "--foreground": "other",
-      "--card": "other",
-      "--card-foreground": "other",
-      "--popover": "other",
-      "--popover-foreground": "other",
-      "--primary": "other",
-      "--primary-foreground": "other",
-      "--secondary": "other",
-      "--secondary-foreground": "other",
-      "--muted": "other",
-      "--muted-foreground": "other",
-      "--accent": "other",
-      "--accent-foreground": "other",
-      "--destructive": "other",
-      "--destructive-foreground": "other",
-      "--border": "other",
-      "--input": "other",
-      "--ring": "other",
-      "--radius": "radius",
-      "--shell-0": "color",
-      "--shell-1": "color",
-      "--shell-2": "color",
-      "--shell-3": "color",
-      "--shell-4": "color",
-      "--shell-5": "color",
-      "--line-subtle": "color",
-      "--line": "color",
-      "--line-strong": "color",
-      "--fill-subtle": "color",
-      "--fill": "color",
-      "--fill-hover": "color",
-      "--text-hi": "font",
-      "--text-1": "font",
-      "--text-2": "font",
-      "--text-3": "font",
-      "--text-4": "font",
-      "--text-5": "font",
-      "--text-slate-500": "font",
-      "--color-bg": "color",
-      "--color-fg": "color",
-      "--surface-card": "color",
-      "--surface-popover": "color",
-      "--text-body": "font",
-      "--text-muted": "font",
-      "--border-default": "color",
-      "--focus-ring": "shadow",
-      "--accent-primary": "color",
-      "--font-sans": "font",
-      "--font-mono": "font",
-      "--font-caption-marker": "font",
-      "--font-caption-hand": "font",
-      "--font-caption-impact": "font",
-      "--font-caption-serif": "font",
-      "--font-caption-grotesk": "font",
-      "--fw-regular": "other",
-      "--fw-medium": "other",
-      "--fw-semibold": "other",
-      "--fw-bold": "other",
-      "--text-9": "font",
-      "--text-10": "font",
-      "--text-11": "font",
-      "--text-12": "font",
-      "--text-13": "font",
-      "--text-sm": "font",
-      "--text-base": "font",
-      "--text-lg": "font",
-      "--text-xl": "font",
-      "--text-2xl": "font",
-      "--lh-none": "other",
-      "--lh-tight": "other",
-      "--lh-snug": "other",
-      "--lh-normal": "other",
-      "--lh-relaxed": "other",
-      "--tracking-tight": "font",
-      "--tracking-normal": "font",
-      "--space-0": "spacing",
-      "--space-0-5": "spacing",
-      "--space-1": "spacing",
-      "--space-1-5": "spacing",
-      "--space-2": "spacing",
-      "--space-2-5": "spacing",
-      "--space-3": "spacing",
-      "--space-3-5": "spacing",
-      "--space-4": "spacing",
-      "--space-5": "spacing",
-      "--space-6": "spacing",
-      "--space-8": "spacing",
-      "--space-10": "spacing",
-      "--space-12": "spacing",
-      "--radius-sm": "radius",
-      "--radius-md": "radius",
-      "--radius-lg": "radius",
-      "--radius-xl": "radius",
-      "--radius-2xl": "radius",
-      "--radius-3xl": "radius",
-      "--radius-window": "radius",
-      "--radius-full": "radius",
-      "--control-h-xs": "spacing",
-      "--control-h-sm": "spacing",
-      "--control-h-md": "spacing",
-      "--control-h-lg": "spacing",
-      "--icon-xs": "spacing",
-      "--icon-sm": "spacing",
-      "--icon-md": "spacing",
-      "--icon-lg": "spacing",
-      "--rail-width": "other",
-      "--workspace-pad": "spacing",
-      "--radius-xs": "radius",
-      "--radius-pill": "radius",
-      "--elev-card": "shadow",
-      "--elev-pop": "shadow",
-      "--glow-accent": "color",
-      "--shadow-hud": "shadow",
-      "--shadow-panel": "shadow",
-      "--shadow-popover": "shadow",
-      "--shadow-card": "shadow",
-      "--shadow-card-hover": "shadow",
-      "--shadow-badge": "shadow",
-      "--shadow-inset-hi": "shadow",
-      "--shadow-capture": "shadow",
-      "--glass-blur": "other",
-      "--glass-blur-strong": "other",
-      "--glass-shell": "other",
-      "--glass-hud": "color",
-      "--glass-popover": "color",
-      "--gradient-workspace": "other",
-      "--gradient-panel": "other",
-      "--gradient-selected": "other",
-      "--dur-fast": "other",
-      "--dur-base": "other",
-      "--dur-mid": "other",
-      "--dur-slow": "other",
-      "--press-scale": "other",
-      "--ring-focus": "color",
-      "--ring-slider": "shadow"
-    },
-    "fontFamilies": [
-      "Bebas Neue",
-      "Caveat",
-      "Fira Code",
-      "Geist",
-      "Geist Mono",
-      "IBM Plex Mono",
-      "Inter",
-      "Oswald",
-      "Permanent Marker",
-      "Playfair Display",
-      "Space Grotesk"
-    ]
-  }
-}
diff --git a/design/_ds_bundle.js b/design/_ds_bundle.js
deleted file mode 100644
index f410753e08..0000000000
--- a/design/_ds_bundle.js
+++ /dev/null
@@ -1,1328 +0,0 @@
-/* @ds-bundle: {"format":4,"namespace":"DesignSystem_d5355e","components":[{"name":"Badge","sourcePath":"components/display/Badge.jsx"},{"name":"Card","sourcePath":"components/display/Card.jsx"},{"name":"Chip","sourcePath":"components/display/Chip.jsx"},{"name":"ProgressBar","sourcePath":"components/display/ProgressBar.jsx"},{"name":"ChatBubble","sourcePath":"components/editor/ChatBubble.jsx"},{"name":"FacetRailButton","sourcePath":"components/editor/FacetRailButton.jsx"},{"name":"MediaCard","sourcePath":"components/editor/MediaCard.jsx"},{"name":"ProposalCard","sourcePath":"components/editor/ProposalCard.jsx"},{"name":"TimelinePill","sourcePath":"components/editor/TimelinePill.jsx"},{"name":"Button","sourcePath":"components/forms/Button.jsx"},{"name":"IconButton","sourcePath":"components/forms/IconButton.jsx"},{"name":"SegmentedControl","sourcePath":"components/forms/SegmentedControl.jsx"},{"name":"Select","sourcePath":"components/forms/Select.jsx"},{"name":"Slider","sourcePath":"components/forms/Slider.jsx"},{"name":"Switch","sourcePath":"components/forms/Switch.jsx"},{"name":"TextField","sourcePath":"components/forms/TextField.jsx"}],"sourceHashes":{"components/display/Badge.jsx":"945d417894b4","components/display/Card.jsx":"0a49c008b484","components/display/Chip.jsx":"e8ce89e14157","components/display/ProgressBar.jsx":"389c60a837a5","components/editor/ChatBubble.jsx":"9fb2d4f5b482","components/editor/FacetRailButton.jsx":"0787738d5dbc","components/editor/MediaCard.jsx":"e7c8e7020f73","components/editor/ProposalCard.jsx":"a9b5577f85d1","components/editor/TimelinePill.jsx":"54dd80c4b997","components/forms/Button.jsx":"da1cbfaa0d8e","components/forms/IconButton.jsx":"acc85205377d","components/forms/SegmentedControl.jsx":"8ead5ca73ac1","components/forms/Select.jsx":"acfccc2a37f2","components/forms/Slider.jsx":"70f722a063d1","components/forms/Switch.jsx":"b6f070e782e5","components/forms/TextField.jsx":"000e9d209e3e"},"inlinedExternals":[],"unexposedExports":[]} */
-
-(() => {
-
-const __ds_ns = (window.DesignSystem_d5355e = window.DesignSystem_d5355e || {});
-
-const __ds_scope = {};
-
-(__ds_ns.__errors = __ds_ns.__errors || []);
-
-// components/display/Badge.jsx
-try { (() => {
-/**
- * OpenScreen Badge — the small status pill. Optional leading dot.
- * tones: accent (default) · neutral · danger · warn. `soft` uses the
- * tinted fill (default); pass soft={false} for a bordered outline.
- */
-function Badge({
-  children,
-  tone = 'accent',
-  dot = false,
-  soft = true,
-  mono = true,
-  style = {}
-}) {
-  const map = {
-    accent: {
-      fg: 'var(--accent)',
-      bg: 'var(--accent-soft)',
-      bd: 'var(--accent-border)',
-      dot: 'var(--accent)'
-    },
-    neutral: {
-      fg: 'var(--muted)',
-      bg: 'var(--surface-2)',
-      bd: 'var(--border)',
-      dot: 'var(--muted)'
-    },
-    danger: {
-      fg: 'var(--danger)',
-      bg: 'var(--danger-soft)',
-      bd: 'var(--danger)',
-      dot: 'var(--danger)'
-    },
-    warn: {
-      fg: 'var(--annotation)',
-      bg: 'var(--annotation-wash)',
-      bd: 'var(--annotation)',
-      dot: 'var(--annotation)'
-    }
-  };
-  const c = map[tone] || map.accent;
-  return /*#__PURE__*/React.createElement("span", {
-    style: {
-      display: 'inline-flex',
-      alignItems: 'center',
-      gap: 5,
-      padding: dot ? '3px 9px 3px 7px' : '3px 9px',
-      borderRadius: 9999,
-      background: soft ? c.bg : 'transparent',
-      border: soft ? 'none' : `1px solid ${c.bd}`,
-      color: c.fg,
-      fontFamily: mono ? 'var(--font-mono)' : 'var(--font-display)',
-      fontSize: mono ? 9.5 : 11.5,
-      fontWeight: 600,
-      whiteSpace: 'nowrap',
-      ...style
-    }
-  }, dot && /*#__PURE__*/React.createElement("span", {
-    style: {
-      width: 4,
-      height: 4,
-      borderRadius: '50%',
-      background: c.dot
-    }
-  }), children);
-}
-Object.assign(__ds_scope, { Badge });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/display/Badge.jsx", error: String((e && e.message) || e) }); }
-
-// components/display/Card.jsx
-try { (() => {
-/**
- * OpenScreen Card — the flat bordered surface container. `elevation`
- * "card" (resting) or "pop" (floating). `level` picks the fill surface.
- * Optional `title` renders a bordered header.
- */
-function Card({
-  children,
-  title = null,
-  headerRight = null,
-  elevation = 'card',
-  level = 1,
-  radius = 14,
-  padding = 14,
-  style = {},
-  bodyStyle = {}
-}) {
-  const fills = {
-    0: 'var(--surface)',
-    1: 'var(--surface-1)',
-    2: 'var(--surface-2)'
-  };
-  return /*#__PURE__*/React.createElement("div", {
-    style: {
-      border: '1px solid var(--border)',
-      borderRadius: radius,
-      background: fills[level] || fills[1],
-      boxShadow: elevation === 'pop' ? 'var(--elev-pop)' : 'var(--elev-card)',
-      overflow: 'hidden',
-      ...style
-    }
-  }, title && /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      alignItems: 'center',
-      gap: 8,
-      padding: '11px 13px 10px',
-      borderBottom: '1px solid var(--border-soft)'
-    }
-  }, /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontSize: 12,
-      fontWeight: 600,
-      color: 'var(--fg)',
-      letterSpacing: '-0.01em'
-    }
-  }, title), headerRight && /*#__PURE__*/React.createElement("span", {
-    style: {
-      marginLeft: 'auto'
-    }
-  }, headerRight)), /*#__PURE__*/React.createElement("div", {
-    style: {
-      padding,
-      ...bodyStyle
-    }
-  }, children));
-}
-Object.assign(__ds_scope, { Card });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/display/Card.jsx", error: String((e && e.message) || e) }); }
-
-// components/display/Chip.jsx
-try { (() => {
-/**
- * OpenScreen Chip — rounded action/filter pill with optional leading
- * icon. Used for the quick-action row above the composer. Hover gives
- * an accent wash + border.
- */
-function Chip({
-  children,
-  icon = null,
-  onClick,
-  style = {}
-}) {
-  const [hover, setHover] = React.useState(false);
-  return /*#__PURE__*/React.createElement("button", {
-    type: "button",
-    onClick: onClick,
-    onMouseEnter: () => setHover(true),
-    onMouseLeave: () => setHover(false),
-    style: {
-      flex: '0 0 auto',
-      display: 'inline-flex',
-      alignItems: 'center',
-      gap: 6,
-      padding: '6px 11px',
-      borderRadius: 9999,
-      background: hover ? 'var(--accent-wash)' : 'var(--surface-1)',
-      border: `1px solid ${hover ? 'var(--accent-border)' : 'var(--border)'}`,
-      color: hover ? 'var(--fg)' : 'var(--fg-2)',
-      fontFamily: 'var(--font-display)',
-      fontSize: 11.5,
-      fontWeight: 500,
-      cursor: 'pointer',
-      whiteSpace: 'nowrap',
-      ...style
-    }
-  }, icon && /*#__PURE__*/React.createElement("span", {
-    style: {
-      color: 'var(--accent)',
-      display: 'inline-flex'
-    }
-  }, icon), children);
-}
-Object.assign(__ds_scope, { Chip });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/display/Chip.jsx", error: String((e && e.message) || e) }); }
-
-// components/display/ProgressBar.jsx
-try { (() => {
-/**
- * OpenScreen ProgressBar — thin track with an emerald (or gradient)
- * fill. Used for the recipe step progress and generic determinate
- * progress. Height defaults to the 3px recipe bar.
- */
-function ProgressBar({
-  value = 0,
-  height = 3,
-  gradient = true,
-  style = {}
-}) {
-  const pct = Math.max(0, Math.min(100, value));
-  return /*#__PURE__*/React.createElement("div", {
-    style: {
-      height,
-      background: 'var(--surface-3)',
-      position: 'relative',
-      borderRadius: height / 2,
-      overflow: 'hidden',
-      ...style
-    }
-  }, /*#__PURE__*/React.createElement("div", {
-    style: {
-      position: 'absolute',
-      left: 0,
-      top: 0,
-      bottom: 0,
-      width: `${pct}%`,
-      background: gradient ? 'linear-gradient(90deg, var(--brand-lo), var(--brand))' : 'var(--accent)'
-    }
-  }));
-}
-Object.assign(__ds_scope, { ProgressBar });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/display/ProgressBar.jsx", error: String((e && e.message) || e) }); }
-
-// components/editor/ChatBubble.jsx
-try { (() => {
-/**
- * OpenScreen ChatBubble — a single agent-conversation row. Handles the
- * three roles: assistant (avatar + left bubble, meta header), user
- * (right, emerald-tinted), system (centered pill).
- */
-function ChatBubble({
-  role = 'assistant',
-  author,
-  time,
-  children,
-  avatar = null
-}) {
-  if (role === 'system') {
-    return /*#__PURE__*/React.createElement("div", {
-      style: {
-        display: 'flex',
-        justifyContent: 'center'
-      }
-    }, /*#__PURE__*/React.createElement("div", {
-      style: {
-        maxWidth: '94%',
-        padding: '6px 13px',
-        borderRadius: 9999,
-        background: 'var(--surface-1)',
-        border: '1px solid var(--border-soft)',
-        color: 'var(--muted)',
-        fontSize: 11.5
-      }
-    }, children));
-  }
-  if (role === 'user') {
-    return /*#__PURE__*/React.createElement("div", {
-      style: {
-        display: 'flex',
-        justifyContent: 'flex-end'
-      }
-    }, /*#__PURE__*/React.createElement("div", {
-      style: {
-        display: 'flex',
-        flexDirection: 'column',
-        gap: 6,
-        alignItems: 'flex-end',
-        maxWidth: '86%'
-      }
-    }, (author || time) && /*#__PURE__*/React.createElement("div", {
-      style: {
-        display: 'flex',
-        alignItems: 'baseline',
-        gap: 8,
-        padding: '0 2px'
-      }
-    }, /*#__PURE__*/React.createElement("span", {
-      style: {
-        fontSize: 11.5,
-        fontWeight: 600,
-        color: 'var(--fg)',
-        letterSpacing: '-0.01em'
-      }
-    }, author), time && /*#__PURE__*/React.createElement("span", {
-      style: {
-        fontFamily: 'var(--font-mono)',
-        fontSize: 10,
-        color: 'var(--meta)'
-      }
-    }, time)), /*#__PURE__*/React.createElement("div", {
-      style: {
-        padding: '10px 14px',
-        borderRadius: '15px 5px 15px 15px',
-        background: 'var(--accent-soft)',
-        border: '1px solid var(--accent-border)',
-        color: 'var(--fg)',
-        fontSize: 13,
-        lineHeight: 1.55
-      }
-    }, children)));
-  }
-  // assistant
-  return /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      gap: 10,
-      alignItems: 'flex-start'
-    }
-  }, /*#__PURE__*/React.createElement("span", {
-    "aria-hidden": "true",
-    style: {
-      width: 26,
-      height: 26,
-      borderRadius: 8,
-      background: 'var(--surface-2)',
-      border: '1px solid var(--border)',
-      flexShrink: 0,
-      marginTop: 2,
-      display: 'grid',
-      placeItems: 'center',
-      color: 'var(--accent)'
-    }
-  }, avatar), /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      flexDirection: 'column',
-      gap: 6,
-      minWidth: 0,
-      maxWidth: '86%'
-    }
-  }, (author || time) && /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      alignItems: 'baseline',
-      gap: 8,
-      padding: '0 2px'
-    }
-  }, /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontSize: 11.5,
-      fontWeight: 600,
-      color: 'var(--fg)',
-      letterSpacing: '-0.01em'
-    }
-  }, author), time && /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontFamily: 'var(--font-mono)',
-      fontSize: 10,
-      color: 'var(--meta)'
-    }
-  }, time)), /*#__PURE__*/React.createElement("div", {
-    style: {
-      padding: '11px 14px',
-      borderRadius: '5px 15px 15px 15px',
-      background: 'var(--surface)',
-      border: '1px solid var(--border)',
-      color: 'var(--fg-2)',
-      fontSize: 13,
-      lineHeight: 1.55,
-      boxShadow: 'var(--elev-card)'
-    }
-  }, children)));
-}
-Object.assign(__ds_scope, { ChatBubble });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/editor/ChatBubble.jsx", error: String((e && e.message) || e) }); }
-
-// components/editor/FacetRailButton.jsx
-try { (() => {
-/**
- * OpenScreen FacetRailButton — an icon button in the vertical facet
- * rail beside the inspector. Active facet gets the emerald-soft fill.
- */
-function FacetRailButton({
-  active = false,
-  title,
-  onClick,
-  children,
-  style = {}
-}) {
-  const [hover, setHover] = React.useState(false);
-  let color = active ? 'var(--accent)' : 'var(--muted)';
-  let background = active ? 'var(--accent-soft)' : 'transparent';
-  if (!active && hover) {
-    color = 'var(--fg)';
-    background = 'var(--surface-3)';
-  }
-  return /*#__PURE__*/React.createElement("button", {
-    type: "button",
-    title: title,
-    "aria-label": title,
-    "aria-pressed": active,
-    onClick: onClick,
-    onMouseEnter: () => setHover(true),
-    onMouseLeave: () => setHover(false),
-    style: {
-      width: 40,
-      height: 40,
-      display: 'grid',
-      placeItems: 'center',
-      border: 0,
-      borderRadius: 11,
-      background,
-      color,
-      cursor: 'pointer',
-      ...style
-    }
-  }, children);
-}
-Object.assign(__ds_scope, { FacetRailButton });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/editor/FacetRailButton.jsx", error: String((e && e.message) || e) }); }
-
-// components/editor/MediaCard.jsx
-try { (() => {
-/**
- * OpenScreen MediaCard — a clip tile in the media library. Gradient
- * thumbnail with a film-strip glyph, a drag-handle affordance, and a
- * name/duration/size footer. Selected → 1.5px emerald border.
- */
-function MediaCard({
-  name,
-  duration,
-  size,
-  from = '#10b981',
-  to = '#0d986a',
-  selected = false,
-  draggable = true,
-  onClick,
-  onDragStart,
-  onDragEnd,
-  style = {}
-}) {
-  return /*#__PURE__*/React.createElement("button", {
-    draggable: draggable,
-    onClick: onClick,
-    onDragStart: onDragStart,
-    onDragEnd: onDragEnd,
-    style: {
-      display: 'flex',
-      flexDirection: 'column',
-      padding: 0,
-      border: `1.5px solid ${selected ? 'var(--accent)' : 'var(--border)'}`,
-      borderRadius: 12,
-      background: 'var(--surface)',
-      overflow: 'hidden',
-      cursor: 'grab',
-      textAlign: 'left',
-      ...style
-    }
-  }, /*#__PURE__*/React.createElement("div", {
-    style: {
-      position: 'relative',
-      height: 84,
-      display: 'grid',
-      placeItems: 'center',
-      background: `linear-gradient(135deg, ${from}, ${to})`
-    }
-  }, /*#__PURE__*/React.createElement("svg", {
-    width: "30",
-    height: "30",
-    viewBox: "0 0 24 24",
-    fill: "none",
-    stroke: "rgba(255,255,255,0.85)",
-    strokeWidth: "1.8",
-    strokeLinecap: "round",
-    strokeLinejoin: "round"
-  }, /*#__PURE__*/React.createElement("rect", {
-    x: "2.5",
-    y: "4",
-    width: "19",
-    height: "16",
-    rx: "2"
-  }), /*#__PURE__*/React.createElement("path", {
-    d: "M7 4v16M17 4v16M2.5 9h4.5M2.5 15h4.5M17 9h4.5M17 15h4.5"
-  })), /*#__PURE__*/React.createElement("span", {
-    "aria-hidden": "true",
-    style: {
-      position: 'absolute',
-      top: 7,
-      left: 7,
-      width: 22,
-      height: 22,
-      display: 'grid',
-      placeItems: 'center',
-      borderRadius: 6,
-      background: 'rgba(8,10,13,0.45)',
-      backdropFilter: 'blur(6px)'
-    }
-  }, /*#__PURE__*/React.createElement("svg", {
-    width: "12",
-    height: "12",
-    viewBox: "0 0 24 24",
-    fill: "rgba(255,255,255,0.9)"
-  }, /*#__PURE__*/React.createElement("circle", {
-    cx: "9",
-    cy: "6",
-    r: "1.6"
-  }), /*#__PURE__*/React.createElement("circle", {
-    cx: "15",
-    cy: "6",
-    r: "1.6"
-  }), /*#__PURE__*/React.createElement("circle", {
-    cx: "9",
-    cy: "12",
-    r: "1.6"
-  }), /*#__PURE__*/React.createElement("circle", {
-    cx: "15",
-    cy: "12",
-    r: "1.6"
-  }), /*#__PURE__*/React.createElement("circle", {
-    cx: "9",
-    cy: "18",
-    r: "1.6"
-  }), /*#__PURE__*/React.createElement("circle", {
-    cx: "15",
-    cy: "18",
-    r: "1.6"
-  })))), /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      alignItems: 'center',
-      gap: 7,
-      padding: '10px 12px'
-    }
-  }, selected && /*#__PURE__*/React.createElement("span", {
-    style: {
-      width: 6,
-      height: 6,
-      borderRadius: '50%',
-      background: 'var(--accent)',
-      flexShrink: 0
-    }
-  }), /*#__PURE__*/React.createElement("div", {
-    style: {
-      minWidth: 0,
-      flex: 1
-    }
-  }, /*#__PURE__*/React.createElement("div", {
-    style: {
-      fontSize: 12.5,
-      fontWeight: 600,
-      color: 'var(--fg)',
-      whiteSpace: 'nowrap',
-      overflow: 'hidden',
-      textOverflow: 'ellipsis'
-    }
-  }, name), /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      justifyContent: 'space-between',
-      gap: 8
-    }
-  }, /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontFamily: 'var(--font-mono)',
-      fontSize: 10.5,
-      color: 'var(--muted)'
-    }
-  }, duration), /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontFamily: 'var(--font-mono)',
-      fontSize: 10.5,
-      color: 'var(--meta)'
-    }
-  }, size)))));
-}
-Object.assign(__ds_scope, { MediaCard });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/editor/MediaCard.jsx", error: String((e && e.message) || e) }); }
-
-// components/editor/ProposalCard.jsx
-try { (() => {
-/**
- * OpenScreen ProposalCard — the agent's "Proposed cuts" card: a header
- * with total + confidence badge, a list of time-range rows with striped
- * clip chips, an apply/review action row, and a rationale footnote.
- */
-function ProposalCard({
-  title = 'Proposed cuts',
-  total,
-  confidence = 'High confidence',
-  items = [],
-  rationale,
-  applyLabel = 'Apply',
-  onApply,
-  onReview
-}) {
-  return /*#__PURE__*/React.createElement("div", {
-    style: {
-      border: '1px solid var(--border)',
-      borderRadius: 14,
-      background: 'var(--surface-1)',
-      overflow: 'hidden',
-      boxShadow: 'var(--elev-card)'
-    }
-  }, /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      alignItems: 'center',
-      gap: 8,
-      padding: '11px 13px 10px',
-      borderBottom: '1px solid var(--border-soft)'
-    }
-  }, /*#__PURE__*/React.createElement("svg", {
-    width: "13",
-    height: "13",
-    viewBox: "0 0 24 24",
-    fill: "none",
-    stroke: "currentColor",
-    strokeWidth: "2",
-    strokeLinecap: "round",
-    strokeLinejoin: "round",
-    style: {
-      color: 'var(--accent)'
-    }
-  }, /*#__PURE__*/React.createElement("path", {
-    d: "M20 6 9 17l-5-5"
-  })), /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontSize: 12,
-      fontWeight: 600,
-      color: 'var(--fg)',
-      letterSpacing: '-0.01em'
-    }
-  }, title), total != null && /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontFamily: 'var(--font-mono)',
-      fontSize: 10,
-      color: 'var(--meta)'
-    }
-  }, "−", total), /*#__PURE__*/React.createElement("span", {
-    style: {
-      marginLeft: 'auto',
-      display: 'inline-flex',
-      alignItems: 'center',
-      gap: 5,
-      padding: '3px 8px',
-      borderRadius: 9999,
-      background: 'var(--accent-soft)',
-      color: 'var(--accent)',
-      fontFamily: 'var(--font-mono)',
-      fontSize: 9.5,
-      fontWeight: 600,
-      border: '1px solid var(--accent-border)'
-    }
-  }, /*#__PURE__*/React.createElement("span", {
-    style: {
-      width: 4,
-      height: 4,
-      borderRadius: '50%',
-      background: 'var(--accent)'
-    }
-  }), confidence)), /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      flexDirection: 'column'
-    }
-  }, items.map((it, i) => /*#__PURE__*/React.createElement("div", {
-    key: i,
-    style: {
-      display: 'flex',
-      alignItems: 'center',
-      gap: 10,
-      padding: '8px 13px',
-      borderBottom: '1px solid var(--border-soft)'
-    }
-  }, /*#__PURE__*/React.createElement("span", {
-    "aria-hidden": "true",
-    style: {
-      width: 16,
-      height: 9,
-      borderRadius: 2,
-      flexShrink: 0,
-      background: 'var(--accent-wash)',
-      backgroundImage: 'repeating-linear-gradient(45deg, var(--accent-stripe) 0, var(--accent-stripe) 3px, transparent 3px, transparent 6px)'
-    }
-  }), /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontFamily: 'var(--font-mono)',
-      fontSize: 11.5,
-      color: 'var(--fg)'
-    }
-  }, it.range), /*#__PURE__*/React.createElement("span", {
-    style: {
-      marginLeft: 'auto',
-      fontFamily: 'var(--font-mono)',
-      fontSize: 10.5,
-      color: 'var(--muted)'
-    }
-  }, "−", it.dur)))), /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      alignItems: 'center',
-      gap: 8,
-      padding: '11px 13px',
-      background: 'var(--surface)'
-    }
-  }, /*#__PURE__*/React.createElement("button", {
-    onClick: onApply,
-    style: {
-      flex: 1,
-      padding: '8px 12px',
-      borderRadius: 10,
-      border: '1px solid var(--accent)',
-      background: 'var(--accent)',
-      color: '#fff',
-      fontSize: 12,
-      fontWeight: 600,
-      cursor: 'pointer',
-      boxShadow: '0 2px 8px -3px var(--accent-soft)'
-    }
-  }, applyLabel), /*#__PURE__*/React.createElement("button", {
-    onClick: onReview,
-    style: {
-      padding: '8px 12px',
-      borderRadius: 10,
-      border: '1px solid var(--border)',
-      background: 'var(--surface-1)',
-      color: 'var(--fg-2)',
-      fontSize: 12,
-      fontWeight: 500,
-      cursor: 'pointer'
-    }
-  }, "Review each")), rationale && /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      alignItems: 'flex-start',
-      gap: 6,
-      padding: '0 13px 12px'
-    }
-  }, /*#__PURE__*/React.createElement("svg", {
-    width: "12",
-    height: "12",
-    viewBox: "0 0 24 24",
-    fill: "none",
-    stroke: "currentColor",
-    strokeWidth: "2",
-    strokeLinecap: "round",
-    strokeLinejoin: "round",
-    style: {
-      color: 'var(--meta)',
-      flexShrink: 0,
-      marginTop: 1
-    }
-  }, /*#__PURE__*/React.createElement("circle", {
-    cx: "12",
-    cy: "12",
-    r: "10"
-  }), /*#__PURE__*/React.createElement("path", {
-    d: "M12 16v-4"
-  }), /*#__PURE__*/React.createElement("path", {
-    d: "M12 8h.01"
-  })), /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontSize: 10.5,
-      color: 'var(--meta)',
-      lineHeight: 1.45
-    }
-  }, rationale)));
-}
-Object.assign(__ds_scope, { ProposalCard });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/editor/ProposalCard.jsx", error: String((e && e.message) || e) }); }
-
-// components/editor/TimelinePill.jsx
-try { (() => {
-/**
- * OpenScreen TimelinePill — a labelled marker on a timeline lane.
- * tone maps to the four lane accents. `fixedWidth` (tag mode) sizes to
- * content; otherwise it spans a range via left/width percentages.
- */
-function TimelinePill({
-  tone = 'accent',
-  icon = null,
-  children,
-  leftPct = 0,
-  widthPct = null,
-  style = {}
-}) {
-  const map = {
-    accent: {
-      c: 'var(--accent)',
-      w: 'var(--accent-soft)'
-    },
-    annotation: {
-      c: 'var(--annotation)',
-      w: 'var(--annotation-wash)'
-    },
-    speed: {
-      c: 'var(--speed)',
-      w: 'var(--speed-wash)'
-    },
-    danger: {
-      c: 'var(--danger)',
-      w: 'var(--danger-soft)'
-    }
-  };
-  const t = map[tone] || map.accent;
-  return /*#__PURE__*/React.createElement("span", {
-    style: {
-      position: 'absolute',
-      top: 1,
-      left: `${leftPct}%`,
-      width: widthPct == null ? 'max-content' : `${widthPct}%`,
-      height: 22,
-      display: 'inline-flex',
-      alignItems: 'center',
-      gap: 5,
-      padding: '0 9px 0 7px',
-      borderRadius: 6,
-      border: `1.5px solid ${t.c}`,
-      background: t.w,
-      color: tone === 'danger' ? 'var(--danger)' : 'var(--fg)',
-      fontSize: 11,
-      fontWeight: 600,
-      whiteSpace: 'nowrap',
-      overflow: 'hidden',
-      boxSizing: 'border-box',
-      ...style
-    }
-  }, icon, children);
-}
-Object.assign(__ds_scope, { TimelinePill });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/editor/TimelinePill.jsx", error: String((e && e.message) || e) }); }
-
-// components/forms/Button.jsx
-try { (() => {
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-/**
- * OpenScreen Button — the primary text action.
- * variants: primary (emerald fill) · secondary (surface + border) · ghost (transparent).
- * Icons are passed as children alongside a label, or use IconButton for icon-only.
- */
-function Button({
-  variant = 'primary',
-  size = 'md',
-  icon = null,
-  iconRight = null,
-  disabled = false,
-  fullWidth = false,
-  onClick,
-  children,
-  style = {},
-  ...rest
-}) {
-  const sizes = {
-    sm: {
-      h: 28,
-      px: 10,
-      fs: 12,
-      gap: 6,
-      radius: 8
-    },
-    md: {
-      h: 32,
-      px: 14,
-      fs: 13,
-      gap: 7,
-      radius: 9
-    },
-    lg: {
-      h: 40,
-      px: 18,
-      fs: 14,
-      gap: 9,
-      radius: 12
-    }
-  };
-  const s = sizes[size] || sizes.md;
-  const variants = {
-    primary: {
-      background: 'var(--accent)',
-      color: '#fff',
-      border: '1px solid var(--accent)',
-      boxShadow: '0 2px 10px -3px var(--accent-soft)'
-    },
-    secondary: {
-      background: 'var(--surface-1)',
-      color: 'var(--fg-2)',
-      border: '1px solid var(--border)'
-    },
-    ghost: {
-      background: 'transparent',
-      color: 'var(--fg-2)',
-      border: '1px solid transparent'
-    }
-  };
-  const v = variants[variant] || variants.primary;
-  const base = {
-    display: 'inline-flex',
-    alignItems: 'center',
-    justifyContent: 'center',
-    gap: s.gap,
-    height: s.h,
-    padding: `0 ${s.px}px`,
-    borderRadius: s.radius,
-    fontFamily: 'var(--font-display)',
-    fontSize: s.fs,
-    fontWeight: 600,
-    lineHeight: 1,
-    cursor: disabled ? 'not-allowed' : 'pointer',
-    opacity: disabled ? 0.45 : 1,
-    whiteSpace: 'nowrap',
-    ...v,
-    ...style
-  };
-  const [hover, setHover] = React.useState(false);
-  const hoverStyle = !disabled && hover ? variant === 'primary' ? {
-    background: 'var(--brand-lo)'
-  } : variant === 'secondary' ? {
-    borderColor: 'var(--border-hi)',
-    color: 'var(--fg)'
-  } : {
-    background: 'var(--surface-1)',
-    borderColor: 'var(--border)'
-  } : {};
-  return /*#__PURE__*/React.createElement("button", _extends({
-    type: "button",
-    disabled: disabled,
-    onClick: onClick,
-    onMouseEnter: () => setHover(true),
-    onMouseLeave: () => setHover(false),
-    style: {
-      ...base,
-      ...hoverStyle,
-      width: fullWidth ? '100%' : undefined
-    }
-  }, rest), icon, children, iconRight);
-}
-Object.assign(__ds_scope, { Button });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/forms/Button.jsx", error: String((e && e.message) || e) }); }
-
-// components/forms/IconButton.jsx
-try { (() => {
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-/**
- * OpenScreen IconButton — square, icon-only. The workhorse of toolbars,
- * the topbar, and floating chrome. Ghost by default; `active` gives the
- * emerald-soft selected look; `tone="danger"` for destructive.
- */
-function IconButton({
-  size = 32,
-  active = false,
-  tone = 'default',
-  disabled = false,
-  title,
-  onClick,
-  children,
-  style = {},
-  ...rest
-}) {
-  const [hover, setHover] = React.useState(false);
-  const rest_ = {
-    default: 'var(--muted)',
-    danger: 'var(--muted)'
-  }[tone];
-  let color = active ? 'var(--accent)' : rest_;
-  let background = active ? 'var(--accent-soft)' : 'transparent';
-  if (!disabled && hover && !active) {
-    if (tone === 'danger') {
-      color = 'var(--danger)';
-      background = 'var(--danger-soft)';
-    } else {
-      color = 'var(--fg)';
-      background = 'var(--surface-2)';
-    }
-  }
-  return /*#__PURE__*/React.createElement("button", _extends({
-    type: "button",
-    title: title,
-    "aria-label": title,
-    "aria-pressed": active || undefined,
-    disabled: disabled,
-    onClick: onClick,
-    onMouseEnter: () => setHover(true),
-    onMouseLeave: () => setHover(false),
-    style: {
-      width: size,
-      height: size,
-      display: 'grid',
-      placeItems: 'center',
-      borderRadius: size <= 28 ? 6 : 9,
-      border: 0,
-      background,
-      color,
-      cursor: disabled ? 'not-allowed' : 'pointer',
-      opacity: disabled ? 0.4 : 1,
-      flexShrink: 0,
-      ...style
-    }
-  }, rest), children);
-}
-Object.assign(__ds_scope, { IconButton });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/forms/IconButton.jsx", error: String((e && e.message) || e) }); }
-
-// components/forms/SegmentedControl.jsx
-try { (() => {
-/**
- * OpenScreen SegmentedControl — the pill-in-a-trough tab switcher.
- * Used for Media/Edit/Rec stage modes, Image/Color/Gradient background
- * tabs, Screen/Window source, etc. The active segment gets a raised
- * surface chip; inactive segments are muted text.
- */
-function SegmentedControl({
-  options = [],
-  value,
-  onChange,
-  size = 'md',
-  style = {}
-}) {
-  const s = size === 'sm' ? {
-    pad: '6px 8px',
-    fs: 11.5,
-    trough: 2,
-    radius: 8,
-    inner: 6
-  } : {
-    pad: '7px 14px',
-    fs: 12.5,
-    trough: 3,
-    radius: 11,
-    inner: 8
-  };
-  return /*#__PURE__*/React.createElement("div", {
-    role: "tablist",
-    style: {
-      display: 'inline-flex',
-      alignItems: 'center',
-      gap: 2,
-      padding: s.trough,
-      background: 'var(--surface-1)',
-      border: '1px solid var(--border)',
-      borderRadius: s.radius,
-      ...style
-    }
-  }, options.map(opt => {
-    const val = typeof opt === 'string' ? opt : opt.value;
-    const label = typeof opt === 'string' ? opt : opt.label;
-    const active = val === value;
-    return /*#__PURE__*/React.createElement("button", {
-      key: val,
-      role: "tab",
-      "aria-selected": active,
-      onClick: () => onChange && onChange(val),
-      style: {
-        padding: s.pad,
-        border: 0,
-        borderRadius: s.inner,
-        cursor: 'pointer',
-        fontFamily: 'var(--font-display)',
-        fontSize: s.fs,
-        fontWeight: 600,
-        lineHeight: 1,
-        background: active ? 'var(--surface-hi)' : 'transparent',
-        color: active ? 'var(--fg-emphasis)' : 'var(--muted)',
-        boxShadow: active ? 'var(--elev-card)' : 'none'
-      }
-    }, label);
-  }));
-}
-Object.assign(__ds_scope, { SegmentedControl });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/forms/SegmentedControl.jsx", error: String((e && e.message) || e) }); }
-
-// components/forms/Select.jsx
-try { (() => {
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-/**
- * OpenScreen Select — native dropdown styled to match. Used for
- * caption style, layout preset, transcript language, etc.
- */
-function Select({
-  options = [],
-  value,
-  onChange,
-  fullWidth = true,
-  style = {},
-  ...rest
-}) {
-  return /*#__PURE__*/React.createElement("select", _extends({
-    value: value,
-    onChange: e => onChange && onChange(e.target.value),
-    style: {
-      width: fullWidth ? '100%' : undefined,
-      height: 36,
-      padding: '0 11px',
-      borderRadius: 10,
-      border: '1px solid var(--border)',
-      background: 'var(--surface-2)',
-      color: 'var(--fg-2)',
-      fontFamily: 'var(--font-display)',
-      fontSize: 12.5,
-      fontWeight: 500,
-      outline: 'none',
-      cursor: 'pointer',
-      ...style
-    }
-  }, rest), options.map(opt => {
-    const val = typeof opt === 'string' ? opt : opt.value;
-    const label = typeof opt === 'string' ? opt : opt.label;
-    return /*#__PURE__*/React.createElement("option", {
-      key: val,
-      value: val
-    }, label);
-  }));
-}
-Object.assign(__ds_scope, { Select });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/forms/Select.jsx", error: String((e && e.message) || e) }); }
-
-// components/forms/Slider.jsx
-try { (() => {
-/**
- * OpenScreen Slider — the labelled range control inside inspector cards.
- * Renders the whole card: label (left) + mono value in emerald (right)
- * above a filled range track. Pass `card={false}` for a bare track.
- */
-function Slider({
-  label,
-  value = 0,
-  min = 0,
-  max = 100,
-  step = 1,
-  format,
-  onChange,
-  card = true,
-  style = {}
-}) {
-  const pct = (value - min) / (max - min) * 100;
-  const trackStyle = {
-    width: '100%',
-    display: 'block',
-    backgroundImage: `linear-gradient(var(--accent),var(--accent)), linear-gradient(var(--surface-3),var(--surface-3))`,
-    backgroundSize: `${pct}% 5px, 100% 5px`
-  };
-  const display = format ? format(value) : value;
-  const input = /*#__PURE__*/React.createElement("input", {
-    type: "range",
-    min: min,
-    max: max,
-    step: step,
-    value: value,
-    onChange: e => onChange && onChange(Number(e.target.value)),
-    style: trackStyle
-  });
-  if (!card) return input;
-  return /*#__PURE__*/React.createElement("div", {
-    style: {
-      border: '1px solid var(--border)',
-      borderRadius: 12,
-      background: 'var(--surface)',
-      padding: '11px 13px',
-      ...style
-    }
-  }, /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      alignItems: 'center',
-      marginBottom: 8
-    }
-  }, /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontSize: 11.5,
-      fontWeight: 500,
-      color: 'var(--fg-2)'
-    }
-  }, label), /*#__PURE__*/React.createElement("span", {
-    style: {
-      fontFamily: 'var(--font-mono)',
-      fontSize: 11,
-      color: 'var(--accent)',
-      marginLeft: 'auto'
-    }
-  }, display)), input);
-}
-Object.assign(__ds_scope, { Slider });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/forms/Slider.jsx", error: String((e && e.message) || e) }); }
-
-// components/forms/Switch.jsx
-try { (() => {
-/**
- * OpenScreen Switch — the pill toggle used in inspector setting rows
- * (Blur background, Mirror webcam, Shrink on zoom, Show cursor…).
- * Track fills emerald when on; knob slides right.
- */
-function Switch({
-  checked = false,
-  onChange,
-  disabled = false,
-  style = {}
-}) {
-  const W = 38,
-    H = 22,
-    KNOB = 16,
-    PAD = 3;
-  return /*#__PURE__*/React.createElement("button", {
-    type: "button",
-    role: "switch",
-    "aria-checked": checked,
-    disabled: disabled,
-    onClick: () => !disabled && onChange && onChange(!checked),
-    style: {
-      position: 'relative',
-      width: W,
-      height: H,
-      flexShrink: 0,
-      border: 0,
-      borderRadius: 9999,
-      cursor: disabled ? 'not-allowed' : 'pointer',
-      opacity: disabled ? 0.5 : 1,
-      background: checked ? 'var(--accent)' : 'var(--surface-3)',
-      transition: 'background .18s var(--ease)',
-      ...style
-    }
-  }, /*#__PURE__*/React.createElement("span", {
-    "aria-hidden": "true",
-    style: {
-      position: 'absolute',
-      top: PAD,
-      left: checked ? W - KNOB - PAD : PAD,
-      width: KNOB,
-      height: KNOB,
-      borderRadius: '50%',
-      background: '#fff',
-      boxShadow: '0 1px 3px rgba(0,0,0,0.35)',
-      transition: 'left .18s var(--ease)'
-    }
-  }));
-}
-Object.assign(__ds_scope, { Switch });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/forms/Switch.jsx", error: String((e && e.message) || e) }); }
-
-// components/forms/TextField.jsx
-try { (() => {
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-/**
- * OpenScreen TextField — one primitive for both single-line inputs and
- * the multiline composer (same border/fill/radius vocabulary).
- * `multiline` swaps <input> for an auto-height <textarea>.
- * `leadingIcon` renders a search/glyph inside a bordered wrapper.
- */
-function TextField({
-  value,
-  onChange,
-  placeholder,
-  multiline = false,
-  leadingIcon = null,
-  rows = 2,
-  style = {},
-  wrapStyle = {},
-  ...rest
-}) {
-  const shared = {
-    width: '100%',
-    minWidth: 0,
-    border: 0,
-    background: 'transparent',
-    fontFamily: 'var(--font-display)',
-    fontSize: 13,
-    lineHeight: 1.5,
-    color: 'var(--fg)',
-    outline: 'none',
-    resize: 'none'
-  };
-  const control = multiline ? /*#__PURE__*/React.createElement("textarea", _extends({
-    value: value,
-    onChange: e => onChange && onChange(e.target.value),
-    placeholder: placeholder,
-    rows: rows,
-    style: {
-      ...shared,
-      minHeight: 28,
-      ...style
-    }
-  }, rest)) : /*#__PURE__*/React.createElement("input", _extends({
-    value: value,
-    onChange: e => onChange && onChange(e.target.value),
-    placeholder: placeholder,
-    style: {
-      ...shared,
-      ...style
-    }
-  }, rest));
-  return /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex',
-      alignItems: multiline ? 'flex-start' : 'center',
-      gap: 10,
-      padding: multiline ? '9px 11px' : '10px 14px',
-      border: '1px solid var(--border)',
-      borderRadius: multiline ? 14 : 10,
-      background: 'var(--surface-1)',
-      ...wrapStyle
-    }
-  }, leadingIcon, control);
-}
-Object.assign(__ds_scope, { TextField });
-})(); } catch (e) { __ds_ns.__errors.push({ path: "components/forms/TextField.jsx", error: String((e && e.message) || e) }); }
-
-__ds_ns.Badge = __ds_scope.Badge;
-
-__ds_ns.Card = __ds_scope.Card;
-
-__ds_ns.Chip = __ds_scope.Chip;
-
-__ds_ns.ProgressBar = __ds_scope.ProgressBar;
-
-__ds_ns.ChatBubble = __ds_scope.ChatBubble;
-
-__ds_ns.FacetRailButton = __ds_scope.FacetRailButton;
-
-__ds_ns.MediaCard = __ds_scope.MediaCard;
-
-__ds_ns.ProposalCard = __ds_scope.ProposalCard;
-
-__ds_ns.TimelinePill = __ds_scope.TimelinePill;
-
-__ds_ns.Button = __ds_scope.Button;
-
-__ds_ns.IconButton = __ds_scope.IconButton;
-
-__ds_ns.SegmentedControl = __ds_scope.SegmentedControl;
-
-__ds_ns.Select = __ds_scope.Select;
-
-__ds_ns.Slider = __ds_scope.Slider;
-
-__ds_ns.Switch = __ds_scope.Switch;
-
-__ds_ns.TextField = __ds_scope.TextField;
-
-})();
diff --git a/design/components/display/Badge.d.ts b/design/components/display/Badge.d.ts
deleted file mode 100644
index 9a87e39762..0000000000
--- a/design/components/display/Badge.d.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-export interface BadgeProps {
-  children?: React.ReactNode;
-  /** @default "accent" */
-  tone?: 'accent' | 'neutral' | 'danger' | 'warn';
-  /** Show a leading status dot. */
-  dot?: boolean;
-  /** Tinted fill (true) vs bordered outline (false). @default true */
-  soft?: boolean;
-  /** Geist Mono (true) vs Geist (false). @default true */
-  mono?: boolean;
-  style?: React.CSSProperties;
-}
-
-/** Small status pill — "Saved", "0% context", "High confidence". */
-export function Badge(props: BadgeProps): JSX.Element;
diff --git a/design/components/display/Badge.prompt.md b/design/components/display/Badge.prompt.md
deleted file mode 100644
index 6fa2a6abba..0000000000
--- a/design/components/display/Badge.prompt.md
+++ /dev/null
@@ -1,9 +0,0 @@
-**Badge** — status pill. Used for save state, context %, confidence, "Not generated yet". Defaults to a soft emerald mono pill with an optional pulsing-style dot.
-
-```jsx
-<Badge dot>Saved</Badge>
-<Badge tone="accent" soft={false} dot>High confidence</Badge>
-<Badge tone="neutral" mono={false}>Not generated yet</Badge>
-```
-
-- `mono` on by default — most badges carry numbers/status codes. Turn off for sentence-case labels.
diff --git a/design/components/display/Card.d.ts b/design/components/display/Card.d.ts
deleted file mode 100644
index e294f80448..0000000000
--- a/design/components/display/Card.d.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import React from 'react';
-
-export interface CardProps {
-  children?: React.ReactNode;
-  /** Optional bordered header title. */
-  title?: React.ReactNode;
-  /** Node pinned to the right of the header. */
-  headerRight?: React.ReactNode;
-  /** Resting card vs floating popover shadow. @default "card" */
-  elevation?: 'card' | 'pop';
-  /** Fill surface level 0–2. @default 1 */
-  level?: 0 | 1 | 2;
-  radius?: number;
-  padding?: number;
-  style?: React.CSSProperties;
-  bodyStyle?: React.CSSProperties;
-}
-
-/** Flat bordered surface container. */
-export function Card(props: CardProps): JSX.Element;
diff --git a/design/components/display/Card.prompt.md b/design/components/display/Card.prompt.md
deleted file mode 100644
index a7a37272f5..0000000000
--- a/design/components/display/Card.prompt.md
+++ /dev/null
@@ -1,8 +0,0 @@
-**Card** — the generic bordered container behind setting rows, popovers, and panels. Use `elevation="pop"` for anything that floats over the stage (inspector, menus), `card` for resting content.
-
-```jsx
-<Card title="Proposed cuts" headerRight={<Badge dot>High</Badge>}>…</Card>
-<Card elevation="pop" level={1} radius={16} padding={0}>…</Card>
-```
-
-- `level` maps to `--surface` / `--surface-1` / `--surface-2`. Nested containers should round less than their parent.
diff --git a/design/components/display/Chip.d.ts b/design/components/display/Chip.d.ts
deleted file mode 100644
index b53da258c6..0000000000
--- a/design/components/display/Chip.d.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import React from 'react';
-
-export interface ChipProps {
-  children?: React.ReactNode;
-  /** Leading icon (rendered in accent). */
-  icon?: React.ReactNode;
-  onClick?: (e: React.MouseEvent) => void;
-  style?: React.CSSProperties;
-}
-
-/** Rounded quick-action / filter pill with hover wash. */
-export function Chip(props: ChipProps): JSX.Element;
diff --git a/design/components/display/Chip.prompt.md b/design/components/display/Chip.prompt.md
deleted file mode 100644
index 63f4a51a2e..0000000000
--- a/design/components/display/Chip.prompt.md
+++ /dev/null
@@ -1,8 +0,0 @@
-**Chip** — tappable rounded pill, typically in a horizontal scroll row of suggested actions above the composer.
-
-```jsx
-<Chip icon={<ArrowRightIcon/>} onClick={fill}>Remove silences</Chip>
-<Chip icon={<ArrowRightIcon/>}>Tighten pacing</Chip>
-```
-
-- Rests on `--surface-1`; hover fills `--accent-wash` with an accent-tinted border and the leading arrow in emerald.
diff --git a/design/components/display/ProgressBar.d.ts b/design/components/display/ProgressBar.d.ts
deleted file mode 100644
index 8273fa5817..0000000000
--- a/design/components/display/ProgressBar.d.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-export interface ProgressBarProps {
-  /** 0–100. */
-  value: number;
-  /** Track height in px. @default 3 */
-  height?: number;
-  /** Emerald gradient fill vs flat accent. @default true */
-  gradient?: boolean;
-  style?: React.CSSProperties;
-}
-
-/** Thin determinate progress track (recipe steps, generic progress). */
-export function ProgressBar(props: ProgressBarProps): JSX.Element;
diff --git a/design/components/display/ProgressBar.prompt.md b/design/components/display/ProgressBar.prompt.md
deleted file mode 100644
index 3a3686a852..0000000000
--- a/design/components/display/ProgressBar.prompt.md
+++ /dev/null
@@ -1,6 +0,0 @@
-**ProgressBar** — thin determinate bar. Default 3px with an emerald gradient, matching the recipe-progress strip under the agent header.
-
-```jsx
-<ProgressBar value={60} />
-<ProgressBar value={40} height={5} gradient={false} />
-```
diff --git a/design/components/editor/ChatBubble.d.ts b/design/components/editor/ChatBubble.d.ts
deleted file mode 100644
index 96c50b3de6..0000000000
--- a/design/components/editor/ChatBubble.d.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import React from 'react';
-
-export interface ChatBubbleProps {
-  /** @default "assistant" */
-  role?: 'assistant' | 'user' | 'system';
-  author?: string;
-  time?: string;
-  /** Avatar glyph for assistant role. */
-  avatar?: React.ReactNode;
-  children?: React.ReactNode;
-}
-
-/** One row in the agent conversation (assistant / user / system). */
-export function ChatBubble(props: ChatBubbleProps): JSX.Element;
diff --git a/design/components/editor/ChatBubble.prompt.md b/design/components/editor/ChatBubble.prompt.md
deleted file mode 100644
index ded1604d26..0000000000
--- a/design/components/editor/ChatBubble.prompt.md
+++ /dev/null
@@ -1,10 +0,0 @@
-**ChatBubble** — one message in the OpenScreen Agent panel.
-
-```jsx
-<ChatBubble role="user" author="YOU">Clean up the intro please.</ChatBubble>
-<ChatBubble role="assistant" author="OpenScreen" time="10:41" avatar={<BotGlyph/>}>On it — scanning track 1…</ChatBubble>
-<ChatBubble role="system">Applied 3 cuts</ChatBubble>
-```
-
-- Assistant bubbles have a distinctive asymmetric radius (`5px 15px 15px 15px`) + avatar; user bubbles mirror it in emerald-soft.
-- For an attached proposal, render a `ProposalCard` as the bubble's child or directly after it.
diff --git a/design/components/editor/FacetRailButton.d.ts b/design/components/editor/FacetRailButton.d.ts
deleted file mode 100644
index 5c17a5494d..0000000000
--- a/design/components/editor/FacetRailButton.d.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import React from 'react';
-
-export interface FacetRailButtonProps {
-  active?: boolean;
-  title?: string;
-  onClick?: () => void;
-  children?: React.ReactNode;
-  style?: React.CSSProperties;
-}
-
-/** Icon button in the vertical inspector facet rail. */
-export function FacetRailButton(props: FacetRailButtonProps): JSX.Element;
diff --git a/design/components/editor/FacetRailButton.prompt.md b/design/components/editor/FacetRailButton.prompt.md
deleted file mode 100644
index 9840925c6b..0000000000
--- a/design/components/editor/FacetRailButton.prompt.md
+++ /dev/null
@@ -1,7 +0,0 @@
-**FacetRailButton** — one icon in the vertical rail that switches the floating inspector's facet (Background, Effects, Layout, Cursor, Captions, Chapters, Transcript, Crop).
-
-```jsx
-<FacetRailButton title="Background" active={facet==='bg'} onClick={()=>setFacet('bg')}><ImageIcon/></FacetRailButton>
-```
-
-- 40×40, radius 11. Active facet = emerald-soft fill; hover steps to `--surface-3`.
diff --git a/design/components/editor/MediaCard.d.ts b/design/components/editor/MediaCard.d.ts
deleted file mode 100644
index 2e886c7d93..0000000000
--- a/design/components/editor/MediaCard.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-export interface MediaCardProps {
-  name: string;
-  duration: string;
-  size: string;
-  /** Thumbnail gradient stops. */
-  from?: string;
-  to?: string;
-  selected?: boolean;
-  draggable?: boolean;
-  onClick?: () => void;
-  onDragStart?: (e: React.DragEvent) => void;
-  onDragEnd?: (e: React.DragEvent) => void;
-  style?: React.CSSProperties;
-}
-
-/** A draggable clip tile in the media library grid. */
-export function MediaCard(props: MediaCardProps): JSX.Element;
diff --git a/design/components/editor/MediaCard.prompt.md b/design/components/editor/MediaCard.prompt.md
deleted file mode 100644
index 1f56d4be32..0000000000
--- a/design/components/editor/MediaCard.prompt.md
+++ /dev/null
@@ -1,8 +0,0 @@
-**MediaCard** — a clip in the media-library grid. Gradient thumbnail (stands in for a real frame), film-strip glyph, drag handle, mono duration/size footer.
-
-```jsx
-<MediaCard name="demo-n8n-as-code-1.mp4" duration="0:02:34.7" size="110 MB"
-  from="#10b981" to="#0d986a" selected onClick={select} onDragStart={…} />
-```
-
-- Selected state = 1.5px emerald border + a dot before the name. Cards are draggable onto the timeline.
diff --git a/design/components/editor/ProposalCard.d.ts b/design/components/editor/ProposalCard.d.ts
deleted file mode 100644
index 1a6ee0aef9..0000000000
--- a/design/components/editor/ProposalCard.d.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-export interface ProposalItem {
-  /** Time range, e.g. "0:31.0 – 0:37.3". */
-  range: string;
-  /** Removed duration, e.g. "6.3s". */
-  dur: string;
-}
-
-export interface ProposalCardProps {
-  title?: string;
-  /** Total removed, shown as −{total} in the header. */
-  total?: string;
-  /** @default "High confidence" */
-  confidence?: string;
-  items: ProposalItem[];
-  rationale?: string;
-  /** Primary button label. @default "Apply" */
-  applyLabel?: string;
-  onApply?: () => void;
-  onReview?: () => void;
-}
-
-/** The agent's proposed-cuts card (header + range rows + actions + rationale). */
-export function ProposalCard(props: ProposalCardProps): JSX.Element;
diff --git a/design/components/editor/ProposalCard.prompt.md b/design/components/editor/ProposalCard.prompt.md
deleted file mode 100644
index ec7828047a..0000000000
--- a/design/components/editor/ProposalCard.prompt.md
+++ /dev/null
@@ -1,15 +0,0 @@
-**ProposalCard** — the distinctive agent output: a reviewable set of proposed edits attached to an assistant message.
-
-```jsx
-<ProposalCard
-  total="0:44.1"
-  confidence="High confidence"
-  applyLabel="Apply 3 cuts"
-  items={[{range:'0:31.0 – 0:37.3', dur:'6.3s'}, …]}
-  rationale="Detected silences over 600ms and 4 filler words."
-  onApply={apply} onReview={review}
-/>
-```
-
-- Time ranges + durations are always Geist Mono. Each row has a striped emerald clip chip.
-- Render it as a child of, or immediately after, an assistant `ChatBubble`.
diff --git a/design/components/editor/TimelinePill.d.ts b/design/components/editor/TimelinePill.d.ts
deleted file mode 100644
index 1c1620d99e..0000000000
--- a/design/components/editor/TimelinePill.d.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import React from 'react';
-
-export interface TimelinePillProps {
-  /** Lane accent. @default "accent" */
-  tone?: 'accent' | 'annotation' | 'speed' | 'danger';
-  icon?: React.ReactNode;
-  children?: React.ReactNode;
-  /** Left offset as % of the lane. */
-  leftPct?: number;
-  /** Width as % of the lane; omit for content-sized (tag) mode. */
-  widthPct?: number | null;
-  style?: React.CSSProperties;
-}
-
-/** Labelled marker on a timeline lane (annotation / speed / skip / zoom). */
-export function TimelinePill(props: TimelinePillProps): JSX.Element;
diff --git a/design/components/editor/TimelinePill.prompt.md b/design/components/editor/TimelinePill.prompt.md
deleted file mode 100644
index 589b48c38e..0000000000
--- a/design/components/editor/TimelinePill.prompt.md
+++ /dev/null
@@ -1,11 +0,0 @@
-**TimelinePill** — a marker on a timeline lane. Position it inside a `position:relative` lane track via `leftPct`/`widthPct`.
-
-```jsx
-<div style={{position:'relative', height:24}}>
-  <TimelinePill tone="speed" leftPct={19} widthPct={5} icon={<ClockIcon/>}>1.5×</TimelinePill>
-  <TimelinePill tone="danger" leftPct={10} widthPct={10}>0:37.3</TimelinePill>
-  <TimelinePill tone="annotation" leftPct={40} icon={<CommentIcon/>}>New annotation</TimelinePill>
-</div>
-```
-
-- `accent`=zoom, `annotation`=amber comment, `speed`=orange ramp, `danger`=red skip/cut.
diff --git a/design/components/forms/Button.d.ts b/design/components/forms/Button.d.ts
deleted file mode 100644
index 70be2a332f..0000000000
--- a/design/components/forms/Button.d.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import React from 'react';
-
-export interface ButtonProps {
-  /** Visual weight. @default "primary" */
-  variant?: 'primary' | 'secondary' | 'ghost';
-  /** @default "md" */
-  size?: 'sm' | 'md' | 'lg';
-  /** Leading icon node (Lucide SVG). */
-  icon?: React.ReactNode;
-  /** Trailing icon node (e.g. chevron). */
-  iconRight?: React.ReactNode;
-  disabled?: boolean;
-  fullWidth?: boolean;
-  onClick?: (e: React.MouseEvent) => void;
-  children?: React.ReactNode;
-  style?: React.CSSProperties;
-}
-
-/**
- * The primary text-action button.
- *
- * @startingPoint section="Forms" subtitle="Primary / secondary / ghost text button" viewport="700x120"
- */
-export function Button(props: ButtonProps): JSX.Element;
diff --git a/design/components/forms/Button.prompt.md b/design/components/forms/Button.prompt.md
deleted file mode 100644
index 629f7083d6..0000000000
--- a/design/components/forms/Button.prompt.md
+++ /dev/null
@@ -1,11 +0,0 @@
-**Button** — the primary text action. Use `primary` for the one main action in a view (Export, Apply cuts, Send), `secondary` for adjacent choices (Review each), `ghost` for low-emphasis toolbar/topbar actions.
-
-```jsx
-<Button variant="primary" icon={<ExportIcon/>}>Export</Button>
-<Button variant="secondary">Review each</Button>
-<Button variant="ghost" size="sm">demo2</Button>
-```
-
-- Primary is emerald with a soft accent glow; darkens to `--brand-lo` on hover.
-- Keep labels short imperative verbs. No emoji.
-- Icon-only actions → use `IconButton` instead.
diff --git a/design/components/forms/IconButton.d.ts b/design/components/forms/IconButton.d.ts
deleted file mode 100644
index d6edd79fa2..0000000000
--- a/design/components/forms/IconButton.d.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import React from 'react';
-
-export interface IconButtonProps {
-  /** Square size in px. @default 32 */
-  size?: number;
-  /** Selected / toggled-on state → emerald-soft fill. */
-  active?: boolean;
-  /** @default "default" */
-  tone?: 'default' | 'danger';
-  disabled?: boolean;
-  /** Used for both title and aria-label. */
-  title?: string;
-  onClick?: (e: React.MouseEvent) => void;
-  /** The icon (Lucide SVG at 24-viewbox, sized ~55% of the button). */
-  children?: React.ReactNode;
-  style?: React.CSSProperties;
-}
-
-/** Square icon-only button — toolbars, topbar, floating chrome. */
-export function IconButton(props: IconButtonProps): JSX.Element;
diff --git a/design/components/forms/IconButton.prompt.md b/design/components/forms/IconButton.prompt.md
deleted file mode 100644
index 86fbce1c5c..0000000000
--- a/design/components/forms/IconButton.prompt.md
+++ /dev/null
@@ -1,11 +0,0 @@
-**IconButton** — icon-only square button, ghost by default. The most-used control in the editor chrome (topbar, timeline toolbar, panel close, transport).
-
-```jsx
-<IconButton title="Settings"><SettingsIcon/></IconButton>
-<IconButton title="Loop" active={loopOn} onClick={toggleLoop}><LoopIcon/></IconButton>
-<IconButton title="Delete clip" tone="danger"><TrashIcon/></IconButton>
-```
-
-- Rests at `--muted`, hovers to `--fg` on `--surface-2`.
-- `active` = emerald-soft fill for toggled tools.
-- Sizes: 26–28px inside dense toolbars (radius 6), 30–34px in the topbar/transport (radius 9). Always pass a `title`.
diff --git a/design/components/forms/SegmentedControl.d.ts b/design/components/forms/SegmentedControl.d.ts
deleted file mode 100644
index 20f43a9da4..0000000000
--- a/design/components/forms/SegmentedControl.d.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-export interface SegmentOption {
-  value: string;
-  label: string;
-}
-
-export interface SegmentedControlProps {
-  /** Segments — plain strings or {value,label} objects. */
-  options: (string | SegmentOption)[];
-  /** Currently selected value. */
-  value: string;
-  onChange?: (value: string) => void;
-  /** @default "md" */
-  size?: 'sm' | 'md';
-  style?: React.CSSProperties;
-}
-
-/** Pill-in-a-trough tab switcher (stage mode, background tabs, source). */
-export function SegmentedControl(props: SegmentedControlProps): JSX.Element;
diff --git a/design/components/forms/SegmentedControl.prompt.md b/design/components/forms/SegmentedControl.prompt.md
deleted file mode 100644
index 7a473a4261..0000000000
--- a/design/components/forms/SegmentedControl.prompt.md
+++ /dev/null
@@ -1,9 +0,0 @@
-**SegmentedControl** — mutually-exclusive tab switcher in a recessed trough. Use for 2–4 short peer choices that swap the view (stage Media/Edit/Rec, background Image/Color/Gradient, source Screen/Window).
-
-```jsx
-<SegmentedControl options={['Media','Edit','Rec']} value={mode} onChange={setMode} />
-<SegmentedControl size="sm" options={['Screen','Window']} value={src} onChange={setSrc} />
-```
-
-- Active segment = raised `--surface-hi` chip with `--elev-card`; inactive = `--muted` text.
-- `md` for topbar-scale switches, `sm` for inside panels/menus.
diff --git a/design/components/forms/Select.d.ts b/design/components/forms/Select.d.ts
deleted file mode 100644
index bb0be31cf1..0000000000
--- a/design/components/forms/Select.d.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-export interface SelectOption { value: string; label: string; }
-
-export interface SelectProps {
-  options: (string | SelectOption)[];
-  value: string;
-  onChange?: (value: string) => void;
-  /** @default true */
-  fullWidth?: boolean;
-  style?: React.CSSProperties;
-}
-
-/** Native <select> styled for OpenScreen (surface-2 fill, 36px tall). */
-export function Select(props: SelectProps): JSX.Element;
diff --git a/design/components/forms/Select.prompt.md b/design/components/forms/Select.prompt.md
deleted file mode 100644
index 686ef86aa3..0000000000
--- a/design/components/forms/Select.prompt.md
+++ /dev/null
@@ -1,7 +0,0 @@
-**Select** — styled native dropdown for a longer list of exclusive options where a segmented control would be too wide (caption style, layout preset, language).
-
-```jsx
-<Select options={['Bold Center','Minimal Bottom','Karaoke','Boxed']} value={style} onChange={setStyle} />
-```
-
-- 36px tall, `--surface-2` fill, radius 10. Pair with a mono uppercase eyebrow label above it.
diff --git a/design/components/forms/Slider.d.ts b/design/components/forms/Slider.d.ts
deleted file mode 100644
index ce57f5656c..0000000000
--- a/design/components/forms/Slider.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-export interface SliderProps {
-  /** Label shown top-left of the card. */
-  label?: string;
-  value: number;
-  min?: number;
-  max?: number;
-  step?: number;
-  /** Formats the mono value shown top-right, e.g. v => `${v}%`. */
-  format?: (v: number) => string | number;
-  onChange?: (v: number) => void;
-  /** Wrap in the bordered setting card. @default true */
-  card?: boolean;
-  style?: React.CSSProperties;
-}
-
-/** Labelled range slider inside an inspector setting card. */
-export function Slider(props: SliderProps): JSX.Element;
diff --git a/design/components/forms/Slider.prompt.md b/design/components/forms/Slider.prompt.md
deleted file mode 100644
index a135acd3ea..0000000000
--- a/design/components/forms/Slider.prompt.md
+++ /dev/null
@@ -1,9 +0,0 @@
-**Slider** — labelled range control. By default renders the full inspector card (label + mono emerald value + filled track). The track uses the global range-slider chrome from `base.css`.
-
-```jsx
-<Slider label="Shadow" value={shadow} onChange={setShadow} format={v => `${v}%`} />
-<Slider label="Zoom" value={zoom} min={0} max={100} format={v => `${(1+v/50).toFixed(1)}×`} />
-```
-
-- Value read-out is always Geist Mono in `--accent`.
-- Pass `card={false}` for a bare track (e.g. embedded elsewhere).
diff --git a/design/components/forms/Switch.d.ts b/design/components/forms/Switch.d.ts
deleted file mode 100644
index 0dd8a65ff1..0000000000
--- a/design/components/forms/Switch.d.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-export interface SwitchProps {
-  checked?: boolean;
-  onChange?: (next: boolean) => void;
-  disabled?: boolean;
-  style?: React.CSSProperties;
-}
-
-/** Pill toggle for boolean inspector settings. Emerald when on. */
-export function Switch(props: SwitchProps): JSX.Element;
diff --git a/design/components/forms/Switch.prompt.md b/design/components/forms/Switch.prompt.md
deleted file mode 100644
index d83909e642..0000000000
--- a/design/components/forms/Switch.prompt.md
+++ /dev/null
@@ -1,11 +0,0 @@
-**Switch** — boolean toggle. Lives at the right edge of an inspector setting row (label on the left).
-
-```jsx
-<div style={{display:'flex',alignItems:'center',justifyContent:'space-between'}}>
-  <span>Blur background</span>
-  <Switch checked={blur} onChange={setBlur} />
-</div>
-```
-
-- Track fills `--accent` when on, `--surface-3` when off; white knob slides.
-- For a choice that changes what's on screen but isn't on/off, use SegmentedControl instead.
diff --git a/design/components/forms/TextField.d.ts b/design/components/forms/TextField.d.ts
deleted file mode 100644
index 3864e8fa95..0000000000
--- a/design/components/forms/TextField.d.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import React from 'react';
-
-export interface TextFieldProps {
-  value?: string;
-  onChange?: (value: string) => void;
-  placeholder?: string;
-  /** Render an auto-height textarea instead of an input. */
-  multiline?: boolean;
-  /** Icon node rendered inside the field (e.g. a search glyph). */
-  leadingIcon?: React.ReactNode;
-  /** Rows when multiline. @default 2 */
-  rows?: number;
-  /** Style for the control element. */
-  style?: React.CSSProperties;
-  /** Style for the bordered wrapper. */
-  wrapStyle?: React.CSSProperties;
-}
-
-/** Text input / composer — single primitive for both single- and multi-line. */
-export function TextField(props: TextFieldProps): JSX.Element;
diff --git a/design/components/forms/TextField.prompt.md b/design/components/forms/TextField.prompt.md
deleted file mode 100644
index 7b136e235f..0000000000
--- a/design/components/forms/TextField.prompt.md
+++ /dev/null
@@ -1,8 +0,0 @@
-**TextField** — text entry. One primitive covers the search input (single-line, radius 10, with a leading search icon) and the chat composer (multiline, radius 14). The composer typically has a toolbar row below it (model pill + send) — compose that around the TextField.
-
-```jsx
-<TextField leadingIcon={<SearchIcon/>} placeholder="Search media…" value={q} onChange={setQ} />
-<TextField multiline placeholder="Describe the edit you want…" value={msg} onChange={setMsg} />
-```
-
-- Wrapper carries the border + `--surface-1` fill; the control itself is borderless/transparent.
diff --git a/design/public/rec-button.png b/design/public/rec-button.png
deleted file mode 100644
index 5e6bbc4fbb..0000000000
Binary files a/design/public/rec-button.png and /dev/null differ
diff --git a/electron/ipc/nativeBridge.ts b/electron/ipc/nativeBridge.ts
index d278836b53..88b90092b3 100644
--- a/electron/ipc/nativeBridge.ts
+++ b/electron/ipc/nativeBridge.ts
@@ -400,25 +400,6 @@ export function registerNativeBridgeHandlers(context: NativeBridgeContext) {
 						case "destroyView":
 							compositorViewService.destroyView(request.payload.id);
 							return createSuccessResponse(requestId, { ok: true });
-						case "export": {
-							const sender = event.sender;
-							const stats = await compositorViewService.export(
-								request.payload.outPath,
-								(frames) => {
-									if (!sender.isDestroyed()) {
-										sender.send("export:native-progress", frames);
-									}
-								},
-							);
-							if (!stats) {
-								return createErrorResponse(
-									requestId,
-									"UNAVAILABLE",
-									"Native compositor addon not present.",
-								);
-							}
-							return createSuccessResponse(requestId, stats);
-						}
 						case "exportMulti": {
 							const sender = event.sender;
 							const stats = await compositorViewService.exportMulti(
diff --git a/electron/main.ts b/electron/main.ts
index 199782072b..a0cb07dcab 100644
--- a/electron/main.ts
+++ b/electron/main.ts
@@ -21,8 +21,6 @@ import {
 import { mainT, setMainLocale } from "./i18n";
 import { getSelectedDesktopSource, registerIpcHandlers } from "./ipc/handlers";
 import { installMainProcessErrorGuards } from "./main-process-errors";
-import { registerFfmpegExportIpc } from "./media/ffmpegExportIpc";
-import { cancelAllExports } from "./media/ffmpegExportService";
 import { acquireStableInstanceLock } from "./singleInstanceLock";
 import { registerSttIpc } from "./stt";
 import {
@@ -507,9 +505,6 @@ app.on("activate", () => {
 app.on("will-quit", () => {
 	unregisterAllGlobalShortcuts();
 	stableInstanceLock?.release();
-	// Kill any ffmpeg still encoding, or quitting mid-export leaves it orphaned
-	// holding the output file. Fire-and-forget: will-quit cannot await.
-	void cancelAllExports();
 });
 
 const appReady = hasSingleInstanceLock ? app.whenReady() : null;
@@ -631,7 +626,6 @@ appReady?.then(async () => {
 		showMainWindow();
 	}
 
-	registerFfmpegExportIpc();
 	registerIpcHandlers(
 		createEditorWindowWrapper,
 		createSourceSelectorWindowWrapper,
diff --git a/electron/media/__fixtures__/fakeFfmpeg.cjs b/electron/media/__fixtures__/fakeFfmpeg.cjs
deleted file mode 100644
index dcdc2c9368..0000000000
--- a/electron/media/__fixtures__/fakeFfmpeg.cjs
+++ /dev/null
@@ -1,49 +0,0 @@
-// A stand-in for ffmpeg so ffmpegEncodeSession's tests stay hermetic — the real
-// binary is not bundled yet, and we do not want tests that depend on a machine's
-// encoders. Behaviour is driven by FAKE_FFMPEG_MODE:
-//
-//   ok       drain stdin, exit 0
-//   fail     drain stdin, print a known message + the byte count, exit 3
-//   count    drain stdin, print the byte count, exit 3 (so the count reaches the
-//            test through the session's stderr tail — the only channel it exposes)
-//   progress emit frame=N progress lines while draining, exit 0
-//   hang     drain stdin and never exit (for cancel())
-//
-// It ignores the ffmpeg argv it is handed; buildFfmpegArgs is asserted separately.
-const mode = process.env.FAKE_FFMPEG_MODE || "ok";
-
-let bytes = 0;
-let frames = 0;
-
-process.stdin.on("data", (chunk) => {
-	bytes += chunk.length;
-	if (mode === "progress") {
-		// Roughly one progress line per MiB, so a test writing a few MB sees several.
-		const next = Math.floor(bytes / (1024 * 1024));
-		if (next > frames) {
-			frames = next;
-			process.stderr.write(`frame=${frames}\nfps=60\n`);
-		}
-	}
-});
-
-process.stdin.on("end", () => {
-	if (mode === "hang") return;
-	if (mode === "fail") {
-		process.stderr.write(`fake ffmpeg: deliberate failure for the test BYTES=${bytes}\n`);
-		process.exit(3);
-	}
-	if (mode === "count") {
-		process.stderr.write(`BYTES=${bytes}\n`);
-		process.exit(3);
-	}
-	process.exit(0);
-});
-
-// `hang` must survive stdin ending: keep the loop alive until we are killed.
-if (mode === "hang") {
-	setInterval(() => {
-		// Nothing to do — an empty timer is exactly what keeps this process
-		// alive so cancel() has something real to kill.
-	}, 1 << 30);
-}
diff --git a/electron/media/ffmpegCapabilities.test.ts b/electron/media/ffmpegCapabilities.test.ts
deleted file mode 100644
index c3e23d67bb..0000000000
--- a/electron/media/ffmpegCapabilities.test.ts
+++ /dev/null
@@ -1,379 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	candidateFfmpegPaths,
-	candidateVideoEncoders,
-	FFMPEG_BINARY_NAME,
-	isLgplBuild,
-	parseAvailableEncoders,
-	pickWorkingEncoder,
-	smokeTestArgs,
-} from "./ffmpegCapabilities";
-
-// Realistic slice of `ffmpeg -encoders` output (truncated for the test):
-// header, capability description, separator, then a mix of video / audio /
-// subtitle / data encoders. The parser must return every real encoder name
-// and nothing from the header / separator / description rows.
-const REALISTIC_ENCODERS_OUTPUT = [
-	"Encoders:",
-	" V..... = Video",
-	" A..... = Audio",
-	" S..... = Subtitle",
-	" D..... = Data",
-	"------",
-	" V..... h264_qsv             H.264 / AVC (Intel Quick Sync Video acceleration) (codec h264)",
-	" V....D h264_amf             AMD AMF H.264 Encoder (codec h264)",
-	" V....D h264_nvenc           NVIDIA NVENC H.264 encoder (codec h264)",
-	" V....D libx264              libx264 H.264 / AVC / MPEG-4 AVC (codec h264)",
-	" A....D aac                  AAC (Advanced Audio Coding)",
-	" D..... bintext              Binary text",
-	" S..... ass                  ASS (Advanced SSA Subtitle)",
-	" V..... h264_videotoolbox    VideoToolbox H.264 Encoder (codec h264)",
-	" V....D h264_vaapi           H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (codec h264) (deprecated)",
-].join("\n");
-
-describe("ffmpegCapabilities", () => {
-	describe("parseAvailableEncoders", () => {
-		it("parses every encoder from the realistic ffmpeg -encoders fixture", () => {
-			const encoders = parseAvailableEncoders(REALISTIC_ENCODERS_OUTPUT);
-			expect(encoders.has("h264_qsv")).toBe(true);
-			expect(encoders.has("h264_amf")).toBe(true);
-			expect(encoders.has("h264_nvenc")).toBe(true);
-			expect(encoders.has("libx264")).toBe(true);
-			expect(encoders.has("aac")).toBe(true);
-			expect(encoders.has("ass")).toBe(true);
-			expect(encoders.has("bintext")).toBe(true);
-			expect(encoders.has("h264_videotoolbox")).toBe(true);
-			expect(encoders.has("h264_vaapi")).toBe(true);
-		});
-
-		it("ignores header, separator and capability-description rows", () => {
-			const encoders = parseAvailableEncoders(REALISTIC_ENCODERS_OUTPUT);
-			// Header word itself must not be treated as an encoder.
-			expect(encoders.has("Encoders")).toBe(false);
-			// Second token of description lines is "=", never added.
-			expect(encoders.has("=")).toBe(false);
-			// Capability nouns at the end of description lines must not leak.
-			expect(encoders.has("Video")).toBe(false);
-			expect(encoders.has("Audio")).toBe(false);
-			expect(encoders.has("Subtitle")).toBe(false);
-			expect(encoders.has("Data")).toBe(false);
-			// Exactly the 9 real encoders from the fixture, nothing else.
-			expect(encoders.size).toBe(9);
-		});
-
-		it("returns an empty set for empty / no-encoder input", () => {
-			expect(parseAvailableEncoders("").size).toBe(0);
-			expect(parseAvailableEncoders("\n").size).toBe(0);
-			expect(parseAvailableEncoders("Encoders:\n------").size).toBe(0);
-		});
-
-		it("tolerates leading whitespace and - in flag positions", () => {
-			const stdout = [
-				"   V----D h264_nvenc  something",
-				"\tA....D aac\t\t\tAAC (Advanced Audio Coding)",
-				"  V....D libx264      libx264 (codec h264)",
-			].join("\n");
-			const encoders = parseAvailableEncoders(stdout);
-			expect(encoders.has("h264_nvenc")).toBe(true);
-			expect(encoders.has("aac")).toBe(true);
-			expect(encoders.has("libx264")).toBe(true);
-		});
-
-		it("accepts CRLF line endings", () => {
-			const encoders = parseAvailableEncoders("V....D h264_nvenc\r\nA....D aac\r\n");
-			expect(encoders.has("h264_nvenc")).toBe(true);
-			expect(encoders.has("aac")).toBe(true);
-			expect(encoders.size).toBe(2);
-		});
-	});
-
-	describe("candidateVideoEncoders", () => {
-		// libopenh264 is bundled in our LGPL ffmpeg, so it is present everywhere and
-		// sits at the floor of every list. There is no WebCodecs path any more, so a
-		// machine with no hardware must still export - just slowly.
-		const SW = "libopenh264";
-
-		it("win32 orders nvidia, intel, amd, then the OS, then software", () => {
-			const all = new Set(["h264_nvenc", "h264_qsv", "h264_amf", "h264_mf", SW]);
-			expect(candidateVideoEncoders(all, "win32")).toEqual([
-				"h264_nvenc",
-				"h264_qsv",
-				"h264_amf",
-				"h264_mf",
-				SW,
-			]);
-		});
-
-		it("drops what the build does not carry", () => {
-			expect(candidateVideoEncoders(new Set(["h264_amf", SW]), "win32")).toEqual(["h264_amf", SW]);
-		});
-
-		it("darwin is videotoolbox then software", () => {
-			expect(candidateVideoEncoders(new Set(["h264_videotoolbox", SW]), "darwin")).toEqual([
-				"h264_videotoolbox",
-				SW,
-			]);
-		});
-
-		it("linux is nvenc, vaapi, then software", () => {
-			expect(candidateVideoEncoders(new Set(["h264_nvenc", "h264_vaapi", SW]), "linux")).toEqual([
-				"h264_nvenc",
-				"h264_vaapi",
-				SW,
-			]);
-		});
-
-		it("falls back to software on a platform we have no list for", () => {
-			expect(candidateVideoEncoders(new Set([SW]), "freebsd")).toEqual([SW]);
-		});
-
-		it("never offers libx264, the fastest thing we measured, because it is GPL", () => {
-			expect(candidateVideoEncoders(new Set(["libx264", "libx265"]), "win32")).toEqual([]);
-		});
-	});
-
-	describe("pickWorkingEncoder", () => {
-		const ALL = new Set(["h264_nvenc", "h264_qsv", "h264_amf", "h264_mf", "libopenh264"]);
-		const encoderIn = (args: string[]) => args[args.indexOf("-c:v") + 1];
-
-		it("skips encoders the build carries but the machine cannot run", async () => {
-			// The real failure this exists to prevent: our bundled binary lists
-			// nvenc/qsv/amf on every machine, so on an AMD box nvenc is present and
-			// dies with "Cannot load nvcuda.dll". Presence is not capability.
-			const works = new Set(["h264_amf", "h264_mf", "libopenh264"]);
-			const picked = await pickWorkingEncoder(ALL, "win32", (args) => works.has(encoderIn(args)));
-			expect(picked).toBe("h264_amf");
-		});
-
-		it("takes the first that works, in preference order", async () => {
-			const picked = await pickWorkingEncoder(ALL, "win32", () => true);
-			expect(picked).toBe("h264_nvenc");
-		});
-
-		it("lands on software when no hardware encoder runs", async () => {
-			const picked = await pickWorkingEncoder(
-				ALL,
-				"win32",
-				(args) => encoderIn(args) === "libopenh264",
-			);
-			expect(picked).toBe("libopenh264");
-		});
-
-		it("returns null when nothing works - the bundled ffmpeg is broken, not the machine", async () => {
-			expect(await pickWorkingEncoder(ALL, "win32", () => false)).toBeNull();
-		});
-
-		it("stops probing once one passes", async () => {
-			const tried: string[] = [];
-			await pickWorkingEncoder(ALL, "win32", (args) => {
-				tried.push(encoderIn(args));
-				return encoderIn(args) === "h264_qsv";
-			});
-			expect(tried).toEqual(["h264_nvenc", "h264_qsv"]);
-		});
-
-		it("awaits an async probe", async () => {
-			const picked = await pickWorkingEncoder(ALL, "win32", async (args) => {
-				await new Promise((r) => setTimeout(r, 1));
-				return encoderIn(args) === "h264_mf";
-			});
-			expect(picked).toBe("h264_mf");
-		});
-	});
-
-	describe("smokeTestArgs", () => {
-		it("encodes one synthetic frame to nowhere, so it touches no files", () => {
-			const a = smokeTestArgs("h264_amf");
-			expect(a[a.indexOf("-f") + 1]).toBe("lavfi");
-			expect(a[a.indexOf("-c:v") + 1]).toBe("h264_amf");
-			expect(a[a.indexOf("-frames:v") + 1]).toBe("1");
-			expect(a.slice(-3)).toEqual(["-f", "null", "-"]);
-		});
-	});
-
-	describe("isLgplBuild", () => {
-		it("rejects a build configured with --enable-gpl", () => {
-			const buildConf = "--prefix=/usr --enable-shared --enable-gpl --enable-version3";
-			expect(isLgplBuild(buildConf)).toBe(false);
-		});
-
-		it("rejects a build configured with --enable-nonfree", () => {
-			const buildConf = "--prefix=/usr --enable-shared --enable-nonfree";
-			expect(isLgplBuild(buildConf)).toBe(false);
-		});
-
-		it("accepts a clean LGPL build (no gpl or nonfree)", () => {
-			const buildConf = "--prefix=/usr --enable-shared --enable-version3 --enable-libvpx";
-			expect(isLgplBuild(buildConf)).toBe(true);
-		});
-
-		it("does not match --enable-gpl as a substring of another flag", () => {
-			// gpl-something is a different flag entirely - not the one we care about.
-			expect(isLgplBuild("--enable-gpl-something")).toBe(true);
-			expect(isLgplBuild("--enable-nonfree-extra")).toBe(true);
-		});
-
-		it("accepts the ffmpeg banner `configuration:` line for a clean build", () => {
-			const banner = "configuration: --prefix=/usr --enable-shared --enable-version3";
-			expect(isLgplBuild(banner)).toBe(true);
-		});
-
-		it("rejects the ffmpeg banner `configuration:` line when --enable-gpl is present", () => {
-			const banner = "configuration: --prefix=/usr --enable-gpl --enable-version3 --enable-libx264";
-			expect(isLgplBuild(banner)).toBe(false);
-		});
-
-		it("rejects the ffmpeg banner `configuration:` line when --enable-nonfree is present", () => {
-			const banner = "configuration: --enable-shared --enable-nonfree --enable-libfdk-aac";
-			expect(isLgplBuild(banner)).toBe(false);
-		});
-
-		it("returns true for an empty / whitespace-only build configuration", () => {
-			expect(isLgplBuild("")).toBe(true);
-			expect(isLgplBuild("   ")).toBe(true);
-		});
-	});
-
-	describe("candidateFfmpegPaths", () => {
-		it("prepends the env override when set", () => {
-			const paths = candidateFfmpegPaths({
-				here: "/fake/repo",
-				platform: "linux",
-				arch: "x64",
-				envOverride: "/custom/ffmpeg",
-			});
-			expect(paths[0]).toBe("/custom/ffmpeg");
-			expect(paths).toContain("/fake/repo/electron/native/bin/linux-x64/ffmpeg");
-		});
-
-		it("emits ffmpeg.exe under <platform>-<arch> on win32", () => {
-			const paths = candidateFfmpegPaths({
-				here: "C:/fake/repo",
-				platform: "win32",
-				arch: "x64",
-			});
-			const resolved = paths.map((p) => p.replace(/\\/g, "/"));
-			expect(resolved).toContain("C:/fake/repo/electron/native/bin/win32-x64/ffmpeg.exe");
-			expect(resolved).toContain("C:/fake/repo/electron/native/bin/ffmpeg.exe");
-		});
-
-		it("emits bare ffmpeg on linux (no .exe anywhere)", () => {
-			const paths = candidateFfmpegPaths({
-				here: "/fake/repo",
-				platform: "linux",
-				arch: "x64",
-			});
-			expect(paths).toContain("/fake/repo/electron/native/bin/linux-x64/ffmpeg");
-			expect(paths).toContain("/fake/repo/electron/native/bin/ffmpeg");
-			expect(paths.every((p) => !p.endsWith(".exe"))).toBe(true);
-		});
-
-		it("emits bare ffmpeg on darwin (no .exe anywhere)", () => {
-			const paths = candidateFfmpegPaths({
-				here: "/fake/repo",
-				platform: "darwin",
-				arch: "arm64",
-			});
-			expect(paths).toContain("/fake/repo/electron/native/bin/darwin-arm64/ffmpeg");
-			expect(paths.every((p) => !p.endsWith(".exe"))).toBe(true);
-		});
-
-		it("orders candidates: env > appPath > resourcesPath > here-tagged > here-bare", () => {
-			const paths = candidateFfmpegPaths({
-				here: "/fake/repo",
-				platform: "linux",
-				arch: "x64",
-				appPath: "/app",
-				resourcesPath: "/res",
-				envOverride: "/env",
-			});
-			// Priority 1: env override comes first.
-			expect(paths[0]).toBe("/env");
-			// Priority 2: appPath-tagged candidate is present.
-			expect(paths).toContain("/app/electron/native/bin/linux-x64/ffmpeg");
-			// Priority 3: resourcesPath-tagged candidate is present.
-			expect(paths).toContain("/res/electron/native/bin/linux-x64/ffmpeg");
-			// Priority 4: here-tagged candidate is present.
-			expect(paths).toContain("/fake/repo/electron/native/bin/linux-x64/ffmpeg");
-			// Priority 5: cross-arch fallthrough with no platform tag is present.
-			expect(paths).toContain("/fake/repo/electron/native/bin/ffmpeg");
-
-			// Order is consistent across the layered candidates.
-			const envIdx = paths.indexOf("/env");
-			const appIdx = paths.indexOf("/app/electron/native/bin/linux-x64/ffmpeg");
-			const resIdx = paths.indexOf("/res/electron/native/bin/linux-x64/ffmpeg");
-			const hereIdx = paths.indexOf("/fake/repo/electron/native/bin/linux-x64/ffmpeg");
-			const bareIdx = paths.indexOf("/fake/repo/electron/native/bin/ffmpeg");
-			expect(envIdx).toBeLessThan(appIdx);
-			expect(appIdx).toBeLessThan(resIdx);
-			expect(resIdx).toBeLessThan(hereIdx);
-			expect(hereIdx).toBeLessThan(bareIdx);
-		});
-
-		it("omits appPath / resourcesPath candidates when those inputs are null", () => {
-			const paths = candidateFfmpegPaths({
-				here: "/fake/repo",
-				platform: "linux",
-				arch: "x64",
-				appPath: null,
-				resourcesPath: null,
-			});
-			expect(paths.some((p) => p.startsWith("/app/"))).toBe(false);
-			expect(paths.some((p) => p.startsWith("/res/"))).toBe(false);
-			expect(paths).toContain("/fake/repo/electron/native/bin/linux-x64/ffmpeg");
-			expect(paths).toContain("/fake/repo/electron/native/bin/ffmpeg");
-		});
-
-		it("skips platform-tagged candidates when platform or arch is missing", () => {
-			const paths = candidateFfmpegPaths({ here: "/fake/repo" });
-			// Only the cross-arch fallthrough is emitted without a platform tag.
-			expect(paths).toEqual(["/fake/repo/electron/native/bin/ffmpeg"]);
-		});
-	});
-
-	describe("FFMPEG_BINARY_NAME", () => {
-		it("returns ffmpeg.exe on win32", () => {
-			expect(FFMPEG_BINARY_NAME("win32")).toBe("ffmpeg.exe");
-		});
-
-		it("returns bare ffmpeg on every other platform", () => {
-			expect(FFMPEG_BINARY_NAME("linux")).toBe("ffmpeg");
-			expect(FFMPEG_BINARY_NAME("darwin")).toBe("ffmpeg");
-			expect(FFMPEG_BINARY_NAME("freebsd")).toBe("ffmpeg");
-		});
-	});
-});
-
-// Added after research surfaced the real GPL/nonfree surface (ffmpeg.org/legal.html):
-// checking --enable-gpl alone is not the whole gate.
-describe("isLgplBuild — GPL externals and nonfree traps", () => {
-	it("rejects each GPL-only external library", () => {
-		for (const lib of [
-			"libx264",
-			"libx265",
-			"libxvid",
-			"libvidstab",
-			"librubberband",
-			"frei0r",
-			"avisynth",
-		]) {
-			expect(isLgplBuild(`--prefix=/x --enable-${lib} --enable-shared`)).toBe(false);
-		}
-	});
-
-	it("rejects libfdk-aac — nonfree makes the binary unredistributable, and we encode AAC", () => {
-		expect(isLgplBuild("--prefix=/x --enable-libfdk-aac")).toBe(false);
-	});
-
-	it("accepts a hardware-only LGPL build with the native aac encoder", () => {
-		expect(
-			isLgplBuild(
-				"--prefix=/x --enable-shared --enable-amf --enable-nvenc --enable-libsvtav1 --enable-videotoolbox",
-			),
-		).toBe(true);
-	});
-
-	it("does not false-positive on a lib whose name merely contains a GPL one", () => {
-		expect(isLgplBuild("--enable-libx264-shim-not-real")).toBe(true);
-	});
-});
diff --git a/electron/media/ffmpegCapabilities.ts b/electron/media/ffmpegCapabilities.ts
deleted file mode 100644
index 96d58823a4..0000000000
--- a/electron/media/ffmpegCapabilities.ts
+++ /dev/null
@@ -1,301 +0,0 @@
-/**
- * Join path segments with forward slashes. Electron's docs and Node's
- * own internals both accept forward slashes on every platform, and using
- * `node:path`'s `path.join` on Windows would silently rewrite the
- * forward-slashed inputs the tests pass into backslashes - breaking the
- * pure-function contract where identical inputs produce identical outputs
- * regardless of host OS.
- */
-function joinPosix(...segments: string[]): string {
-	return segments.filter((s) => s.length > 0).join("/");
-}
-
-/**
- * Resolves the bundled ffmpeg binary for the export path's hardware-accelerated
- * encoder. The actual subprocess, muxing and bitstream handling live in a
- * separate module; this file only does pure capability detection so the
- * streaming layer can stay focused on I/O and the tests can run without ever
- * spawning a process.
- *
- * The resolution pattern mirrors electron/stt/gpuDetector.ts: a single
- * per-platform binary name (Win32 needs the .exe suffix so the OS image
- * loader can resolve it) and a layered set of candidate paths so the same
- * code works in npm run dev, the electron-builder staging tree and the
- * packaged installer.
- */
-
-/** ffmpeg encoders we know how to drive, best-first per platform. */
-export type VideoEncoderId =
-	| "h264_nvenc"
-	| "h264_qsv"
-	| "h264_amf"
-	| "h264_videotoolbox"
-	| "h264_vaapi"
-	/** Media Foundation: reaches AMD/Intel/NVIDIA through the OS rather than a
-	 *  vendor SDK. A useful net when the vendor encoder is missing or broken. */
-	| "h264_mf"
-	/** Cisco's OpenH264 — BSD, so LGPL-safe, and present in our bundled build.
-	 *  Software, therefore slow; it exists so that a machine with no usable
-	 *  hardware encoder can still export rather than being told it cannot. */
-	| "libopenh264";
-
-/**
- * Conventional binary name. Win32's loader requires the .exe suffix; on
- * every other platform ffmpeg is just ffmpeg. The argument exists so tests
- * can drive the function without mutating process.platform.
- */
-export const FFMPEG_BINARY_NAME: (platform: NodeJS.Platform) => string = (platform) =>
-	platform === "win32" ? "ffmpeg.exe" : "ffmpeg";
-
-/**
- * Encoder preference per platform, best first. The first entry present in
- * `available` wins.
- *
- * Windows prefers NVIDIA, then Intel, then AMD: NVENC is the strongest and most
- * predictable of the three, QSV next, AMF last. AMF being last is about
- * throughput headroom, not quality — measured output was frame-identical to
- * software on the reference machine. Even AMF on an integrated Radeon measured
- * ~165 fps at 1080p versus ~8 fps for WebCodecs, so last place is still ~20x
- * what we shipped before.
- *
- * `h264_mf` (Media Foundation) sits after the vendor encoders as an OS-level
- * net: it reaches AMD/Intel/NVIDIA silicon without their SDKs, so it can save a
- * machine whose vendor path is missing or broken.
- *
- * Every list ends in `libopenh264` — software, BSD-licensed, bundled. It is the
- * floor, not a fallback to somewhere else: there is deliberately no WebCodecs
- * path any more, so a machine with no usable hardware encoder still exports
- * through this same code, mux and all, just slowly. That is why this function
- * cannot return null.
- */
-const ENCODER_PREFERENCE: Partial<Record<NodeJS.Platform, readonly VideoEncoderId[]>> = {
-	win32: ["h264_nvenc", "h264_qsv", "h264_amf", "h264_mf", "libopenh264"],
-	darwin: ["h264_videotoolbox", "libopenh264"],
-	linux: ["h264_nvenc", "h264_vaapi", "libopenh264"],
-};
-
-/** Last resort on an unrecognised platform: if ffmpeg runs at all, this is there. */
-const UNIVERSAL_FALLBACK: VideoEncoderId = "libopenh264";
-
-/** Match ffmpeg -encoders flag columns: 6 capability characters from
- *  V/A/S/D plus . (unset) and - (also unset on some builds). The flag
- *  prefix is followed by whitespace, then the encoder name. */
-const ENCODER_FLAG_PATTERN = /^[-VASD.]{6}$/;
-
-/** Encoder names are always identifier-shaped; rejects description lines like
- *  "V..... = Video" whose second token is "=". */
-const ENCODER_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-
-/**
- * Where to look for the bundled ffmpeg, in priority order:
- *   1. OPENSCREEN_FFMPEG_EXE env override (debug builds)
- *   2. <appPath>/electron/native/bin/<platform>-<arch>/<name> (dev npm run
- *      dev and electron-builder --dir unpacked staging)
- *   3. <resourcesPath>/electron/native/bin/<platform>-<arch>/<name>
- *      (packaged installer - NSIS / dmg / AppImage put natives under
- *      resources/)
- *   4. here/electron/native/bin/<platform>-<arch>/<name> (older checkout
- *      shape + bare-bones tests)
- *   5. here/electron/native/bin/<name> (cross-arch fallthrough - same name,
- *      no platform tag, lets a single checked-in binary serve every host)
- *
- * ponytail: on Windows we accept both ffmpeg.exe and bare ffmpeg as
- * candidate names so a checkout that pre-dates the suffix fix still resolves
- * to a valid file.
- *
- * Everything is read through the options bag so this function stays pure -
- * the streaming layer injects appPath / resourcesPath from the Electron
- * context, and tests pass literals.
- */
-export function candidateFfmpegPaths(
-	opts: {
-		here?: string;
-		platform?: NodeJS.Platform;
-		arch?: string;
-		appPath?: string | null;
-		resourcesPath?: string | null;
-		envOverride?: string | null;
-	} = {},
-): string[] {
-	const here = opts.here ?? process.cwd();
-	const platform = opts.platform;
-	const arch = opts.arch;
-	const appPath = opts.appPath ?? null;
-	const resourcesPath = opts.resourcesPath ?? null;
-	const envOverride = opts.envOverride ?? null;
-
-	const tag = platform && arch ? `${platform}-${arch}` : null;
-	const primary = platform ? FFMPEG_BINARY_NAME(platform) : "ffmpeg";
-	const names = platform === "win32" ? [primary, "ffmpeg"] : [primary];
-
-	const appPathSegments =
-		appPath && tag ? names.map((n) => joinPosix(appPath, "electron", "native", "bin", tag, n)) : [];
-	const resourceSegments =
-		resourcesPath && tag
-			? names.map((n) => joinPosix(resourcesPath, "electron", "native", "bin", tag, n))
-			: [];
-	const hereSegments = tag
-		? names.map((n) => joinPosix(here, "electron", "native", "bin", tag, n))
-		: [];
-
-	return [
-		...(envOverride ? [envOverride] : []),
-		...appPathSegments,
-		...resourceSegments,
-		...hereSegments,
-		// Cross-arch fallthrough: bare name with no platform tag - covers the
-		// case where a dev checked in a single ffmpeg for their host only.
-		...names.map((n) => joinPosix(here, "electron", "native", "bin", n)),
-	];
-}
-
-/**
- * Parse ffmpeg -encoders stdout into the set of available encoder names.
- * Returns every encoder (video, audio, subtitle, data) - the caller filters
- * down to the VideoEncoderIds it cares about, so a future codec like
- * hevc_nvenc doesn't require touching this parser.
- *
- * Tolerant of leading whitespace (real ffmpeg output is sometimes
- * space-padded under the banner) and of - in flag positions (some builds
- * render -- instead of .. for unset capabilities).
- */
-export function parseAvailableEncoders(stdout: string): Set<string> {
-	const available = new Set<string>();
-	for (const rawLine of stdout.split(/\r?\n/)) {
-		const line = rawLine.trim();
-		if (line.length === 0) continue;
-		const tokens = line.split(/\s+/);
-		if (tokens.length < 2) continue;
-		if (!ENCODER_FLAG_PATTERN.test(tokens[0])) continue;
-		if (!ENCODER_NAME_PATTERN.test(tokens[1])) continue;
-		available.add(tokens[1]);
-	}
-	return available;
-}
-
-/**
- * The encoders worth *trying* on `platform`, best first, filtered to those the
- * binary actually carries.
- *
- * **This is a shortlist, not a choice.** `ffmpeg -encoders` reports what was
- * compiled in, which for a portable build is every vendor at once: our own
- * bundled binary offers h264_nvenc, h264_qsv and h264_amf on a machine that has
- * only an AMD GPU, where nvenc dies with "Cannot load nvcuda.dll" and qsv with
- * "Error creating a MFX session". Presence proves nothing about the hardware.
- * Only {@link smokeTestArgs} settles it — see {@link pickWorkingEncoder}.
- *
- * Note we never reach for libx264 even though it is the fastest thing we
- * measured (201 fps). That is a licensing call, not a speed one — it is GPL and
- * would relicense this MIT app (see isLgplBuild). libopenh264 is BSD and costs
- * us nothing but throughput on the rare machine that needs it.
- */
-export function candidateVideoEncoders(
-	available: ReadonlySet<string>,
-	platform: NodeJS.Platform,
-): VideoEncoderId[] {
-	const order = ENCODER_PREFERENCE[platform] ?? [UNIVERSAL_FALLBACK];
-	return order.filter((id) => available.has(id));
-}
-
-/**
- * argv for a one-frame encode that answers the only question that matters: does
- * this encoder work *on this machine*? Synthesises its own input (`lavfi`) and
- * throws the output away (`-f null`), so it touches no files and takes ~100 ms.
- */
-export function smokeTestArgs(encoder: VideoEncoderId): string[] {
-	return [
-		"-hide_banner",
-		"-v",
-		"error",
-		"-f",
-		"lavfi",
-		"-i",
-		"color=c=black:s=320x240:d=0.1",
-		"-frames:v",
-		"1",
-		"-c:v",
-		encoder,
-		"-f",
-		"null",
-		"-",
-	];
-}
-
-/**
- * First encoder in the platform's preference order that survives a real one-frame
- * encode. `runSmokeTest` returns true when ffmpeg exits 0 for the given argv —
- * injected so this stays pure and testable without spawning anything.
- *
- * Returns null only when nothing works, which means the bundled ffmpeg is broken
- * or missing rather than the machine being unsupported: libopenh264 is software
- * and part of the build, so it should always pass. Callers must treat null as a
- * hard error — with no WebCodecs path any more, there is nothing else to try.
- */
-export async function pickWorkingEncoder(
-	available: ReadonlySet<string>,
-	platform: NodeJS.Platform,
-	runSmokeTest: (args: string[]) => Promise<boolean> | boolean,
-): Promise<VideoEncoderId | null> {
-	for (const id of candidateVideoEncoders(available, platform)) {
-		if (await runSmokeTest(smokeTestArgs(id))) return id;
-	}
-	return null;
-}
-
-/**
- * External libraries ffmpeg documents as GPL-only. Enabling any one of them
- * relicenses the WHOLE binary to GPL, which would contaminate this MIT app.
- * Belt-and-braces: `--enable-gpl` is *required* to build these, so checking
- * the flag alone should suffice — but a third-party build could be patched,
- * and this is the list that actually decides the licence, so assert on it too.
- * Source: ffmpeg.org/legal.html.
- */
-const GPL_EXTERNAL_LIBS = [
-	"libx264",
-	"libx265",
-	"libxvid",
-	"libxavs",
-	"libxavs2",
-	"libdavs2",
-	"libvidstab",
-	"librubberband",
-	"libcdio",
-	"frei0r",
-	"avisynth",
-] as const;
-
-/**
- * Libraries that make the binary *unredistributable* — worse than GPL, since
- * no licence lets us ship the result at all. `libfdk-aac` is the trap here:
- * it is the AAC encoder everyone reaches for, and we encode AAC. Use ffmpeg's
- * native `aac` encoder instead. Source: ffmpeg.org/legal.html.
- */
-const NONFREE_LIBS = ["libfdk-aac", "libfdk_aac", "openssl"] as const;
-
-/**
- * True iff the ffmpeg build has NO GPL and NO nonfree component.
- *
- * ffmpeg is LGPL **by default** — there is no `--disable-gpl`; GPL only
- * appears if someone passes `--enable-gpl` (pulling x264/x265/…) or
- * `--enable-nonfree` (fdk-aac, OpenSSL-combined builds). It is all-or-nothing:
- * one GPL component relicenses the entire binary.
- *
- * This exists so CI can fail a build that would relicense the app — the whole
- * reason we build/ship ffmpeg ourselves is that we control these flags.
- *
- * Feed it `ffmpeg -buildconf` output, or the banner's `configuration:` line.
- */
-export function isLgplBuild(buildConf: string): boolean {
-	// Token-bounded so `--enable-gpl` matches but `--enable-gpl-something` does
-	// not. The banner's `configuration:` line and a raw `-buildconf` dump are
-	// both space-separated flags.
-	if (/(?:^|\s)--enable-(?:gpl|nonfree)(?=\s|$)/.test(buildConf)) return false;
-
-	for (const lib of [...GPL_EXTERNAL_LIBS, ...NONFREE_LIBS]) {
-		// Matches --enable-libx264 and the bare token some -buildconf dumps use.
-		if (new RegExp(String.raw`(?:^|\s)(?:--enable-)?${lib}(?=\s|$)`).test(buildConf)) {
-			return false;
-		}
-	}
-	return true;
-}
diff --git a/electron/media/ffmpegEncodeSession.test.ts b/electron/media/ffmpegEncodeSession.test.ts
deleted file mode 100644
index f33032f8e5..0000000000
--- a/electron/media/ffmpegEncodeSession.test.ts
+++ /dev/null
@@ -1,225 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-import {
-	buildFfmpegArgs,
-	type FfmpegEncodeOptions,
-	parseProgress,
-	startFfmpegEncodeSession,
-} from "./ffmpegEncodeSession";
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const FAKE = path.join(here, "__fixtures__", "fakeFfmpeg.cjs");
-
-/** Drives the session against the fake ffmpeg instead of the real (unbundled) binary. */
-function fakeOpts(over: Partial<FfmpegEncodeOptions> = {}): FfmpegEncodeOptions {
-	return {
-		ffmpegPath: process.execPath,
-		ffmpegArgsPrefix: [FAKE],
-		outputPath: path.join(here, "__fixtures__", "out.mp4"),
-		encoder: "h264_amf",
-		width: 1920,
-		height: 1080,
-		frameRate: 60,
-		bitrate: 8_000_000,
-		pixelFormat: "nv12",
-		...over,
-	};
-}
-
-function withMode<T>(mode: string, fn: () => Promise<T>): Promise<T> {
-	const prev = process.env.FAKE_FFMPEG_MODE;
-	process.env.FAKE_FFMPEG_MODE = mode;
-	return fn().finally(() => {
-		if (prev === undefined) delete process.env.FAKE_FFMPEG_MODE;
-		else process.env.FAKE_FFMPEG_MODE = prev;
-	});
-}
-
-describe("buildFfmpegArgs", () => {
-	it("feeds rawvideo on stdin with the frame geometry ffmpeg cannot infer", () => {
-		const a = buildFfmpegArgs(fakeOpts({ ffmpegArgsPrefix: undefined }));
-		expect(a).toContain("-f");
-		expect(a[a.indexOf("-f") + 1]).toBe("rawvideo");
-		expect(a[a.indexOf("-s") + 1]).toBe("1920x1080");
-		expect(a[a.indexOf("-r") + 1]).toBe("60");
-		expect(a[a.indexOf("-i") + 1]).toBe("pipe:0");
-	});
-
-	it("passes the pixel format through for both frame layouts", () => {
-		for (const pixelFormat of ["nv12", "bgra", "rgba"] as const) {
-			const a = buildFfmpegArgs(fakeOpts({ pixelFormat }));
-			expect(a[a.indexOf("-pix_fmt") + 1]).toBe(pixelFormat);
-		}
-	});
-
-	it("selects the encoder and bitrate, and disables audio when there is none", () => {
-		const a = buildFfmpegArgs(fakeOpts({ encoder: "h264_videotoolbox", bitrate: 12_000_000 }));
-		expect(a[a.indexOf("-c:v") + 1]).toBe("h264_videotoolbox");
-		expect(a[a.indexOf("-b:v") + 1]).toBe("12000000");
-		expect(a).toContain("-an");
-	});
-
-	it("declares the PCM as a second raw input and lets ffmpeg encode AAC", () => {
-		const a = buildFfmpegArgs(
-			fakeOpts({
-				audio: { path: "/tmp/a.pcm", sampleRate: 48000, channels: 2, bitrate: 192_000 },
-			}),
-		);
-		// f32le with an explicit rate/layout: raw PCM carries no header to infer from.
-		expect(a[a.indexOf("-f", a.indexOf("-i")) + 1]).toBe("f32le");
-		expect(a[a.indexOf("-ar") + 1]).toBe("48000");
-		expect(a[a.indexOf("-ac") + 1]).toBe("2");
-		expect(a).toContain("/tmp/a.pcm");
-		expect(a[a.indexOf("-c:a") + 1]).toBe("aac");
-		expect(a[a.indexOf("-b:a") + 1]).toBe("192000");
-		expect(a).not.toContain("-an");
-	});
-
-	it("declares both inputs before any codec option, as ffmpeg requires", () => {
-		const a = buildFfmpegArgs(
-			fakeOpts({
-				audio: { path: "/tmp/a.pcm", sampleRate: 48000, channels: 2, bitrate: 192_000 },
-			}),
-		);
-		const lastInput = a.lastIndexOf("-i");
-		expect(lastInput).toBeLessThan(a.indexOf("-c:v"));
-		expect(lastInput).toBeLessThan(a.indexOf("-c:a"));
-		// pipe:0 is input 0 and the PCM is input 1 — that ordering is what makes
-		// video stream 0 and audio stream 1 in the output.
-		expect(a.indexOf("pipe:0")).toBeLessThan(a.indexOf("/tmp/a.pcm"));
-	});
-
-	it("asks for machine-readable progress on stderr", () => {
-		const a = buildFfmpegArgs(fakeOpts());
-		expect(a[a.indexOf("-progress") + 1]).toBe("pipe:2");
-		expect(a).toContain("-nostats");
-	});
-
-	it("puts the output path last so nothing can be mistaken for it", () => {
-		const a = buildFfmpegArgs(fakeOpts({ outputPath: "/tmp/x.mp4" }));
-		expect(a[a.length - 1]).toBe("/tmp/x.mp4");
-		expect(a[a.length - 2]).toBe("-y");
-	});
-
-	it("keeps extraEncoderArgs with the encoder, before the output", () => {
-		const a = buildFfmpegArgs(fakeOpts({ extraEncoderArgs: ["-quality", "speed"] }));
-		expect(a.indexOf("-quality")).toBeGreaterThan(a.indexOf("-c:v"));
-		expect(a.indexOf("-quality")).toBeLessThan(a.indexOf("-y"));
-	});
-
-	it("puts ffmpegArgsPrefix first so a wrapper can be invoked", () => {
-		expect(buildFfmpegArgs(fakeOpts({ ffmpegArgsPrefix: ["/w.js"] }))[0]).toBe("/w.js");
-	});
-});
-
-describe("parseProgress", () => {
-	it("reads frame= out of a progress block", () => {
-		expect(parseProgress("frame=42\nfps=60\nout_time_ms=700000\n")).toEqual({ frame: 42 });
-	});
-
-	it("returns the freshest count when a chunk carries several blocks", () => {
-		expect(parseProgress("frame=1\nfps=60\nframe=2\nfps=60\nframe=3\n")).toEqual({ frame: 3 });
-	});
-
-	it("ignores a chunk with no frame count", () => {
-		expect(parseProgress("fps=60\nbitrate=N/A\n")).toBeNull();
-		expect(parseProgress("")).toBeNull();
-	});
-
-	it("ignores a frame= torn across a chunk boundary rather than reporting a truncated number", () => {
-		// The stream splits anywhere; "frame=12" here is the head of "frame=1234".
-		// Reporting 12 would make progress jump backwards on the next chunk.
-		expect(parseProgress("fps=60\nframe=12")).toBeNull();
-		expect(parseProgress("34\nfps=60\nframe=1234\n")).toEqual({ frame: 1234 });
-	});
-
-	it("tolerates surrounding garbage", () => {
-		expect(parseProgress("some error text\nframe=7\n")).toEqual({ frame: 7 });
-	});
-});
-
-describe("startFfmpegEncodeSession", () => {
-	it("resolves with the output path when ffmpeg exits cleanly", async () => {
-		await withMode("ok", async () => {
-			const s = startFfmpegEncodeSession(fakeOpts());
-			await s.writeFrame(new Uint8Array(1024));
-			await expect(s.finish()).resolves.toEqual({ outputPath: fakeOpts().outputPath });
-		});
-	});
-
-	it("rejects with the stderr tail when ffmpeg exits non-zero", async () => {
-		await withMode("fail", async () => {
-			const s = startFfmpegEncodeSession(fakeOpts());
-			await s.writeFrame(new Uint8Array(1024));
-			await expect(s.finish()).rejects.toThrow(/deliberate failure for the test/);
-		});
-	});
-
-	it("rejects rather than emitting an unhandled error when the binary does not exist", async () => {
-		const s = startFfmpegEncodeSession(
-			fakeOpts({ ffmpegPath: path.join(here, "no-such-binary-xyz"), ffmpegArgsPrefix: [] }),
-		);
-		await expect(s.finish()).rejects.toThrow();
-	});
-
-	it("loses no bytes under backpressure", async () => {
-		// The pipe only sustains ~500 MB/s because writeFrame awaits 'drain'. Ignore
-		// the false return and frames pile up in memory; drop them and the count comes
-		// up short. 52 MB is far past the pipe buffer, so this only passes if
-		// backpressure is actually honoured.
-		//
-		// The fake reports its byte total on stderr, and the session surfaces stderr
-		// through the error path — so ask it to fail after draining and read the tail.
-		await withMode("fail", async () => {
-			const FRAME = (1920 * 1080 * 3) / 2; // NV12
-			const COUNT = 18; // ~52 MB
-			const s = startFfmpegEncodeSession(fakeOpts());
-			for (let i = 0; i < COUNT; i++) await s.writeFrame(new Uint8Array(FRAME));
-			await expect(s.finish()).rejects.toThrow(/deliberate failure/);
-			expect(s.framesEncoded).toBe(0); // no progress lines in this mode
-		});
-	});
-
-	it("delivers every byte to ffmpeg's stdin", async () => {
-		// Same contract as above, asserted directly: the fake counts what it received
-		// and prints BYTES=<n>, which reaches us via the failure path's stderr tail.
-		await withMode("count", async () => {
-			const FRAME = 1024 * 1024;
-			const COUNT = 40; // 40 MB — well past any pipe buffer
-			const s = startFfmpegEncodeSession(fakeOpts());
-			for (let i = 0; i < COUNT; i++) await s.writeFrame(new Uint8Array(FRAME));
-			await expect(s.finish()).rejects.toThrow(new RegExp(`BYTES=${FRAME * COUNT}\\b`));
-		});
-	});
-
-	it("reports progress from ffmpeg's stderr", async () => {
-		await withMode("progress", async () => {
-			const seen: number[] = [];
-			const s = startFfmpegEncodeSession(fakeOpts(), { onProgress: (n) => seen.push(n) });
-			for (let i = 0; i < 4; i++) await s.writeFrame(new Uint8Array(1024 * 1024));
-			await s.finish();
-			expect(seen.length).toBeGreaterThan(0);
-			expect(s.framesEncoded).toBe(seen[seen.length - 1]);
-		});
-	});
-
-	it("cancel() kills a hung ffmpeg and leaves finish() able to settle", async () => {
-		await withMode("hang", async () => {
-			const s = startFfmpegEncodeSession(fakeOpts());
-			await s.writeFrame(new Uint8Array(1024));
-			await s.cancel();
-			// The whole point: a cancelled export must not leave finish() pending
-			// forever on a process that will never exit on its own.
-			await expect(s.finish()).resolves.toEqual({ outputPath: fakeOpts().outputPath });
-		});
-	});
-
-	it("refuses writes after cancel instead of throwing EPIPE at the main process", async () => {
-		await withMode("hang", async () => {
-			const s = startFfmpegEncodeSession(fakeOpts());
-			await s.cancel();
-			await expect(s.writeFrame(new Uint8Array(16))).rejects.toThrow(/closed/);
-		});
-	});
-});
diff --git a/electron/media/ffmpegEncodeSession.ts b/electron/media/ffmpegEncodeSession.ts
deleted file mode 100644
index 496b85075e..0000000000
--- a/electron/media/ffmpegEncodeSession.ts
+++ /dev/null
@@ -1,257 +0,0 @@
-import type { ChildProcessByStdio } from "node:child_process";
-import { spawn } from "node:child_process";
-import { once } from "node:events";
-import type { Readable, Writable } from "node:stream";
-
-/** We pipe stdin and stderr and discard stdout — ffmpeg writes the file itself. */
-type FfmpegChild = ChildProcessByStdio<Writable, null, Readable>;
-
-/**
- * Streams raw frames from the export pipeline into a bundled native ffmpeg,
- * which encodes with the platform's hardware encoder and writes the file
- * itself. Replaces WebCodecs + the JS muxer on the export path: WebCodecs
- * reaches the same silicon but measures ~8 fps @1080p against ffmpeg's ~165.
- *
- * Runs in the main process. Deliberately free of Electron imports so it stays
- * unit-testable outside Electron. Binary path and encoder come from
- * {@link ../media/ffmpegCapabilities}; this module never resolves them itself.
- */
-
-export interface FfmpegEncodeOptions {
-	ffmpegPath: string;
-	/**
-	 * argv inserted before ours. Tests use it to point `ffmpegPath` at
-	 * `process.execPath` and run a fake-ffmpeg script instead of the real binary.
-	 */
-	ffmpegArgsPrefix?: string[];
-	outputPath: string;
-	/** e.g. "h264_amf" — chosen by selectVideoEncoder(). */
-	encoder: string;
-	width: number;
-	height: number;
-	frameRate: number;
-	/** bits per second */
-	bitrate: number;
-	/**
-	 * `nv12` is the fast path (3.0 MB/frame @1080p, produced by a GPU packing
-	 * step). `bgra` is what a canvas VideoFrame gives us directly (7.9 MB) —
-	 * Chromium refuses to convert to NV12, so ffmpeg's swscale does it instead.
-	 */
-	pixelFormat: "nv12" | "bgra" | "rgba";
-	extraEncoderArgs?: string[];
-	/**
-	 * Optional second input: the export's assembled PCM, already laid out at the
-	 * concat plan's offsets. Given this, ffmpeg encodes AAC and muxes the final
-	 * file itself — which is the whole point of routing audio through here rather
-	 * than muxing in JS.
-	 *
-	 * Raw f32le rather than WAV: it is what we already hold in memory, it needs no
-	 * header, and it skips the int16 round-trip a WAV would impose.
-	 */
-	audio?: {
-		/** Path to raw interleaved float32 PCM. */
-		path: string;
-		sampleRate: number;
-		channels: number;
-		/** bits per second */
-		bitrate: number;
-	};
-}
-
-export interface FfmpegEncodeSession {
-	/** Resolves once ffmpeg has accepted the frame; awaits `drain` under backpressure. */
-	writeFrame(frame: Uint8Array): Promise<void>;
-	/** Closes stdin; resolves on a clean exit, rejects with the stderr tail otherwise. */
-	finish(): Promise<{ outputPath: string }>;
-	/** Kills the process tree. `finish()` must not hang afterwards. */
-	cancel(): Promise<void>;
-	readonly framesEncoded: number;
-}
-
-/** Keep the last of ffmpeg's stderr: on failure it is the only diagnostic anyone gets. */
-const STDERR_TAIL_BYTES = 4096;
-
-/**
- * The argv we hand ffmpeg. Split out from the process handling so the shape can
- * be asserted without spawning anything.
- *
- * `-progress pipe:2` asks for machine-readable `key=value` progress on stderr,
- * which is what {@link parseProgress} reads; `-nostats` silences the human
- * progress line that would otherwise interleave with it.
- *
- * All inputs must precede the output options, so audio (input 1) is declared
- * right after the video pipe (input 0) and its codec is chosen further down.
- */
-export function buildFfmpegArgs(opts: FfmpegEncodeOptions): string[] {
-	return [
-		...(opts.ffmpegArgsPrefix ?? []),
-		"-hide_banner",
-		"-v",
-		"error",
-		// input 0: raw frames on stdin. rawvideo carries no geometry, so ffmpeg
-		// cannot infer any of this — it must be told.
-		"-f",
-		"rawvideo",
-		"-pix_fmt",
-		opts.pixelFormat,
-		"-s",
-		`${opts.width}x${opts.height}`,
-		"-r",
-		String(opts.frameRate),
-		"-i",
-		"pipe:0",
-		// input 1: the assembled PCM, when there is audio.
-		...(opts.audio
-			? [
-					"-f",
-					"f32le",
-					"-ar",
-					String(opts.audio.sampleRate),
-					"-ac",
-					String(opts.audio.channels),
-					"-i",
-					opts.audio.path,
-				]
-			: []),
-		"-c:v",
-		opts.encoder,
-		"-b:v",
-		String(opts.bitrate),
-		...(opts.extraEncoderArgs ?? []),
-		...(opts.audio ? ["-c:a", "aac", "-b:a", String(opts.audio.bitrate)] : ["-an"]),
-		// Video is exactly as long as the frames we push; audio is sized from the
-		// same per-segment frame counts, so a mismatch means an upstream bug we
-		// want to see rather than have ffmpeg quietly pad or truncate.
-		"-progress",
-		"pipe:2",
-		"-nostats",
-		"-y",
-		opts.outputPath,
-	];
-}
-
-/**
- * Pulls `frame=N` out of a chunk of ffmpeg's `-progress` output, or null when
- * the chunk carries no frame count.
- *
- * Callers feed raw stream chunks, which split anywhere — including mid-line and
- * mid-number. Matching only on a `frame=` followed by digits AND a terminator
- * means a torn `frame=12` at a chunk boundary is ignored rather than reported as
- * frame 12; the next chunk carries the whole line anyway. Progress is monotonic,
- * so taking the LAST match in a chunk gives the freshest count.
- */
-export function parseProgress(chunk: string): { frame: number } | null {
-	let last: number | null = null;
-	// Require real trailing whitespace, NOT end-of-string: a chunk ending in
-	// "frame=12" is the head of "frame=1234", and end-of-string in the lookahead
-	// would happily report 12. ffmpeg's -progress always terminates each
-	// key=value with a newline, so a complete line always has its terminator.
-	for (const m of chunk.matchAll(/(?:^|\s)frame=\s*(\d+)(?=\s)/g)) {
-		const n = Number.parseInt(m[1], 10);
-		if (Number.isFinite(n)) last = n;
-	}
-	return last === null ? null : { frame: last };
-}
-
-/** Windows leaves orphans behind a bare kill() — ffmpeg would keep holding the output file. */
-function killTree(child: FfmpegChild): void {
-	if (child.exitCode !== null || child.signalCode !== null) return;
-	if (process.platform === "win32" && child.pid !== undefined) {
-		spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on(
-			"error",
-			() => {
-				// taskkill missing (unlikely) — fall back to the best we have.
-				child.kill("SIGKILL");
-			},
-		);
-	} else {
-		child.kill("SIGKILL");
-	}
-}
-
-export function startFfmpegEncodeSession(
-	opts: FfmpegEncodeOptions,
-	hooks?: { onProgress?: (framesEncoded: number) => void },
-): FfmpegEncodeSession {
-	const child: FfmpegChild = spawn(opts.ffmpegPath, buildFfmpegArgs(opts), {
-		stdio: ["pipe", "ignore", "pipe"],
-	});
-
-	let framesEncoded = 0;
-	let stderrTail = "";
-	let cancelled = false;
-	let closed = false;
-	let spawnError: Error | null = null;
-
-	// Attached before the first write so a spawn failure surfaces through
-	// finish() instead of as an unhandled 'error' event.
-	const exited: Promise<{ code: number | null; signal: NodeJS.Signals | null }> = new Promise(
-		(resolve) => {
-			child.on("error", (err) => {
-				spawnError = err instanceof Error ? err : new Error(String(err));
-				resolve({ code: null, signal: null });
-			});
-			child.on("close", (code, signal) => {
-				closed = true;
-				resolve({ code, signal });
-			});
-		},
-	);
-
-	child.stdin.on("error", () => {
-		// A killed ffmpeg closes the pipe under us mid-write. EPIPE here is
-		// expected and must never reach the main process as an unhandled error.
-	});
-
-	child.stderr.setEncoding("utf8");
-	child.stderr.on("data", (chunk: string) => {
-		stderrTail = (stderrTail + chunk).slice(-STDERR_TAIL_BYTES);
-		const p = parseProgress(chunk);
-		if (p) {
-			framesEncoded = p.frame;
-			hooks?.onProgress?.(framesEncoded);
-		}
-	});
-
-	return {
-		get framesEncoded() {
-			return framesEncoded;
-		},
-
-		async writeFrame(frame: Uint8Array): Promise<void> {
-			if (cancelled || closed) throw new Error("ffmpeg encode session is closed");
-			if (spawnError) throw spawnError;
-			// Buffer.from(typedArray) COPIES. Wrapping the caller's memory instead
-			// measured +31% end-to-end (26 -> 34 fps): at 3-8 MB a frame, a stray
-			// copy per frame is gigabytes of pure memcpy across an export.
-			const view = Buffer.from(frame.buffer, frame.byteOffset, frame.byteLength);
-			// The pipe sustains ~500 MB/s ONLY if we respect backpressure. Ignoring
-			// the false return buffers frames in memory without going any faster.
-			if (!child.stdin.write(view)) {
-				await once(child.stdin, "drain");
-			}
-		},
-
-		async finish(): Promise<{ outputPath: string }> {
-			if (!cancelled && !closed) child.stdin.end();
-			const { code, signal } = await exited;
-			if (spawnError) throw spawnError;
-			if (cancelled) return { outputPath: opts.outputPath };
-			if (code !== 0) {
-				const how = signal ? `signal ${signal}` : `exit code ${code}`;
-				throw new Error(`ffmpeg failed (${how})${stderrTail ? `: ${stderrTail.trim()}` : ""}`);
-			}
-			return { outputPath: opts.outputPath };
-		},
-
-		async cancel(): Promise<void> {
-			if (cancelled || closed) return;
-			cancelled = true;
-			// End stdin first so ffmpeg is not blocked writing into a full pipe
-			// while we wait on the kill.
-			child.stdin.destroy();
-			killTree(child);
-			await exited;
-		},
-	};
-}
diff --git a/electron/media/ffmpegExportIpc.ts b/electron/media/ffmpegExportIpc.ts
deleted file mode 100644
index d072879554..0000000000
--- a/electron/media/ffmpegExportIpc.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import { ipcMain } from "electron";
-import {
-	cancelExport,
-	finishExport,
-	resolveExportCapabilities,
-	type StartExportRequest,
-	startExport,
-	writeExportFrame,
-} from "./ffmpegExportService";
-
-/**
- * IPC surface for the native export encoder.
- *
- * The renderer composites and extracts frames but cannot spawn ffmpeg — it is
- * sandboxed and stays that way. Dropping the sandbox (option A') was measured
- * and buys nothing: with the crossing at exactly zero the pipeline still loses
- * to WebCodecs, because the wall is the compositor, not this path. See
- * technical-documentation/architecture/export-pipeline.md
- *
- * This whole path is REFUTED (§5): feeding native ffmpeg from the renderer is
- * 2.1x SLOWER than what we ship. It survives as bench scaffolding, not as a
- * plan.
- *
- * Frames are `send`, not `invoke`: they are one-way and there is nothing to
- * return. Flow control is the renderer's credit window (8 frames in flight),
- * acknowledged by `EXPORT_FRAME_ACK` — measured worth +56% over stop-and-wait.
- */
-
-export const EXPORT_CAPABILITIES = "export:capabilities";
-export const EXPORT_START = "export:start";
-export const EXPORT_FRAME = "export:frame";
-export const EXPORT_FRAME_ACK = "export:frame-ack";
-export const EXPORT_FINISH = "export:finish";
-export const EXPORT_CANCEL = "export:cancel";
-
-export function registerFfmpegExportIpc(): void {
-	ipcMain.handle(EXPORT_CAPABILITIES, async () => {
-		const { encoder } = await resolveExportCapabilities();
-		return { encoder };
-	});
-
-	ipcMain.handle(EXPORT_START, async (_e, req: StartExportRequest) => startExport(req));
-
-	ipcMain.on(EXPORT_FRAME, async (e, sessionId: string, frame: ArrayBuffer) => {
-		try {
-			await writeExportFrame(sessionId, frame);
-			// Ack even on the last frame: the renderer's window must refill or it
-			// will stall short of the end.
-			if (!e.sender.isDestroyed()) e.sender.send(EXPORT_FRAME_ACK, sessionId, null);
-		} catch (err) {
-			// A write failure means ffmpeg died mid-export. Report it on the ack
-			// channel rather than throwing into an ipcMain.on handler, where the
-			// rejection would be unhandled and the renderer would wait forever.
-			if (!e.sender.isDestroyed()) {
-				e.sender.send(EXPORT_FRAME_ACK, sessionId, (err as Error).message);
-			}
-		}
-	});
-
-	ipcMain.handle(EXPORT_FINISH, async (_e, sessionId: string) => finishExport(sessionId));
-	ipcMain.handle(EXPORT_CANCEL, async (_e, sessionId: string) => cancelExport(sessionId));
-}
diff --git a/electron/media/ffmpegExportService.ts b/electron/media/ffmpegExportService.ts
deleted file mode 100644
index 5ab2bb7060..0000000000
--- a/electron/media/ffmpegExportService.ts
+++ /dev/null
@@ -1,222 +0,0 @@
-import { spawn } from "node:child_process";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import {
-	candidateFfmpegPaths,
-	parseAvailableEncoders,
-	pickWorkingEncoder,
-	type VideoEncoderId,
-} from "./ffmpegCapabilities";
-import { type FfmpegEncodeSession, startFfmpegEncodeSession } from "./ffmpegEncodeSession";
-
-/**
- * Main-process side of the native export encoder: resolves the bundled ffmpeg,
- * proves which encoder actually works on this machine, and owns the live encode
- * sessions the renderer streams frames into.
- *
- * The renderer cannot spawn anything (it is sandboxed, and stays that way), so
- * frames cross to us over IPC and we feed ffmpeg's stdin. ffmpeg encodes, muxes
- * the audio and writes the file — there is no JS muxer and no WebCodecs path
- * behind this.
- */
-
-export interface StartExportRequest {
-	/**
-	 * Omit to have main write to a temp file and return the path.
-	 *
-	 * The renderer is sandboxed and does not get to name a path main will write
-	 * to — that would hand a compromised renderer an arbitrary file write. A
-	 * user-chosen destination must come from a main-side save dialog, and the
-	 * finished temp file is moved there.
-	 */
-	outputPath?: string;
-	width: number;
-	height: number;
-	frameRate: number;
-	bitrate: number;
-	pixelFormat: "nv12" | "bgra" | "rgba";
-	/** Raw interleaved float32 PCM. ffmpeg encodes AAC and muxes it. */
-	audio?: { pcm: ArrayBuffer; sampleRate: number; channels: number; bitrate: number };
-}
-
-export interface StartExportResult {
-	sessionId: string;
-	encoder: VideoEncoderId;
-	/** Where ffmpeg is actually writing — main's choice when the caller omitted one. */
-	outputPath: string;
-}
-
-/** Resolved once per process: the probe costs a few spawns, the answer never changes. */
-let capabilitiesPromise: Promise<{ ffmpegPath: string; encoder: VideoEncoderId }> | null = null;
-
-async function firstExisting(paths: string[]): Promise<string | null> {
-	for (const p of paths) {
-		try {
-			await fs.access(p);
-			return p;
-		} catch {
-			// Expected: candidateFfmpegPaths lists every layout we might be running
-			// under (dev tree, unpacked staging, packaged resources); most miss.
-		}
-	}
-	return null;
-}
-
-function runFfmpeg(ffmpegPath: string, args: string[]): Promise<{ code: number; stdout: string }> {
-	return new Promise((resolve) => {
-		const child = spawn(ffmpegPath, args, { stdio: ["ignore", "pipe", "ignore"] });
-		let stdout = "";
-		child.stdout?.setEncoding("utf8");
-		child.stdout?.on("data", (c: string) => {
-			stdout += c;
-		});
-		child.on("error", () => resolve({ code: -1, stdout: "" }));
-		child.on("close", (code) => resolve({ code: code ?? -1, stdout }));
-	});
-}
-
-/**
- * Which encoder this machine can really use. Cached: the smoke tests spawn ffmpeg
- * a few times, and hardware does not change under a running app.
- *
- * The smoke test is the whole point. `ffmpeg -encoders` reports what was compiled
- * in — our portable build lists nvenc, qsv and amf on every machine — so on an
- * AMD box nvenc is "available" and then dies with "Cannot load nvcuda.dll".
- * Presence is not capability; only a real one-frame encode settles it.
- */
-export function resolveExportCapabilities(): Promise<{
-	ffmpegPath: string;
-	encoder: VideoEncoderId;
-}> {
-	capabilitiesPromise ??= (async () => {
-		const ffmpegPath = await firstExisting(
-			candidateFfmpegPaths({
-				platform: process.platform,
-				arch: process.arch,
-				appPath: process.env.OPENSCREEN_APP_PATH ?? null,
-				resourcesPath: process.resourcesPath ?? null,
-				envOverride: process.env.OPENSCREEN_FFMPEG_EXE ?? null,
-			}),
-		);
-		if (!ffmpegPath) {
-			throw new Error(
-				"Bundled ffmpeg not found. Run `npm run fetch:ffmpeg` in development; " +
-					"in a packaged build this means the binary was not shipped.",
-			);
-		}
-
-		const listed = await runFfmpeg(ffmpegPath, ["-hide_banner", "-encoders"]);
-		const available = parseAvailableEncoders(listed.stdout);
-		const encoder = await pickWorkingEncoder(
-			available,
-			process.platform,
-			async (args) => (await runFfmpeg(ffmpegPath, args)).code === 0,
-		);
-		if (!encoder) {
-			// libopenh264 is software and part of our build, so it should always pass.
-			// Reaching here means the binary is broken, not that the machine is
-			// unsupported — and there is no other path to fall back to.
-			throw new Error(
-				"No usable H.264 encoder in the bundled ffmpeg — not even software. " +
-					"The bundled binary is broken or was replaced.",
-			);
-		}
-		return { ffmpegPath, encoder };
-	})();
-	return capabilitiesPromise;
-}
-
-interface LiveSession {
-	session: FfmpegEncodeSession;
-	/** Temp PCM handed to ffmpeg as its second input; ours to delete. */
-	audioPath: string | null;
-	tmpDir: string | null;
-}
-
-const sessions = new Map<string, LiveSession>();
-let nextId = 1;
-
-export async function startExport(req: StartExportRequest): Promise<StartExportResult> {
-	const { ffmpegPath, encoder } = await resolveExportCapabilities();
-
-	const sessionId = `export-${nextId++}`;
-
-	let audioPath: string | null = null;
-	let tmpDir: string | null = null;
-	if (req.audio && req.audio.pcm.byteLength > 0) {
-		// ffmpeg reads raw f32le straight from disk. Writing the PCM out beats a
-		// second pipe: it is small (a few MB), and stdin is already carrying video.
-		tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "openscreen-export-"));
-		audioPath = path.join(tmpDir, "audio.f32le");
-		await fs.writeFile(audioPath, Buffer.from(req.audio.pcm));
-	}
-
-	// Deliberately NOT inside tmpDir: dispose() wipes that, and the output has to
-	// outlive the session so it can be moved to the user's destination.
-	const outputPath = req.outputPath ?? path.join(os.tmpdir(), `openscreen-${sessionId}.mp4`);
-
-	const session = startFfmpegEncodeSession({
-		ffmpegPath,
-		encoder,
-		outputPath,
-		width: req.width,
-		height: req.height,
-		frameRate: req.frameRate,
-		bitrate: req.bitrate,
-		pixelFormat: req.pixelFormat,
-		audio:
-			audioPath && req.audio
-				? {
-						path: audioPath,
-						sampleRate: req.audio.sampleRate,
-						channels: req.audio.channels,
-						bitrate: req.audio.bitrate,
-					}
-				: undefined,
-	});
-
-	sessions.set(sessionId, { session, audioPath, tmpDir });
-	return { sessionId, encoder, outputPath };
-}
-
-function requireSession(sessionId: string): LiveSession {
-	const live = sessions.get(sessionId);
-	if (!live) throw new Error(`Unknown export session: ${sessionId}`);
-	return live;
-}
-
-export async function writeExportFrame(sessionId: string, frame: ArrayBuffer): Promise<void> {
-	// Buffer.from(arrayBuffer) wraps rather than copies — the +31% we measured
-	// depends on not duplicating a multi-MB frame here.
-	await requireSession(sessionId).session.writeFrame(new Uint8Array(frame));
-}
-
-async function dispose(sessionId: string, live: LiveSession): Promise<void> {
-	sessions.delete(sessionId);
-	if (live.tmpDir) await fs.rm(live.tmpDir, { recursive: true, force: true });
-}
-
-export async function finishExport(sessionId: string): Promise<{ outputPath: string }> {
-	const live = requireSession(sessionId);
-	try {
-		return await live.session.finish();
-	} finally {
-		await dispose(sessionId, live);
-	}
-}
-
-export async function cancelExport(sessionId: string): Promise<void> {
-	const live = sessions.get(sessionId);
-	if (!live) return; // Already finished or never started: cancelling is idempotent.
-	try {
-		await live.session.cancel();
-	} finally {
-		await dispose(sessionId, live);
-	}
-}
-
-/** Kill every live session — called when the app quits so no ffmpeg is orphaned. */
-export async function cancelAllExports(): Promise<void> {
-	await Promise.all([...sessions.keys()].map((id) => cancelExport(id)));
-}
diff --git a/electron/native-bridge/services/compositorViewService.ts b/electron/native-bridge/services/compositorViewService.ts
index bbea4a529c..396207506a 100644
--- a/electron/native-bridge/services/compositorViewService.ts
+++ b/electron/native-bridge/services/compositorViewService.ts
@@ -400,22 +400,6 @@ export class CompositorViewService {
 		addon.destroyView(id);
 	}
 
-	/** Native export (fixture -> MP4, C8). Auto-pauses live previews to free the GPU.
-	 *  `onProgress` (frames encoded so far) is optional, forwarded straight from the addon's
-	 *  own throttled (~10/s) callback — cheap, the encode loop already ticks this per frame.
-	 *  Returns null when the addon is absent. */
-	async export(
-		outPath?: string,
-		onProgress?: (frames: number) => void,
-	): Promise<ExportStats | null> {
-		const addon = this.ensureAddon();
-		if (!addon) {
-			return null;
-		}
-		const target = outPath ?? path.join(app.getPath("temp"), "openscreen-native-export.mp4");
-		return addon.export(target, onProgress);
-	}
-
 	/** Native multiclip export (real timeline -> MP4). Auto-pauses previews via the addon.
 	 *  `sceneJson` — same scene as the live preview (background/layout/webcam/cursor/effects);
 	 *  goes through the same asset-path resolution as `setScene` (wallpaper image, cursor theme
diff --git a/package.json b/package.json
index b21d459d99..ff602516f4 100644
--- a/package.json
+++ b/package.json
@@ -55,18 +55,14 @@
 		"test:e2e": "playwright test",
 		"test:e2e:windows-native-checklist": "playwright test tests/e2e/windows-native-checklist.spec.ts",
 		"prepare": "husky",
-		"fetch:ffmpeg": "node scripts/fetch-ffmpeg.mjs",
-		"bench:export": "node scripts/bench-export.mjs"
+		"fetch:ffmpeg": "node scripts/fetch-ffmpeg.mjs"
 	},
 	"dependencies": {
 		"@fix-webm-duration/fix": "^1.0.1",
 		"@langchain/anthropic": "^1.3.26",
 		"@langchain/core": "^1.1.44",
-		"@langchain/langgraph": "^1.2.7",
-		"@langchain/langgraph-checkpoint": "^1.0.2",
 		"@langchain/mistralai": "^1.0.8",
 		"@langchain/openai": "^1.4.2",
-		"@pixi/filter-drop-shadow": "^5.2.0",
 		"@radix-ui/react-accordion": "^1.2.12",
 		"@radix-ui/react-dialog": "^1.1.15",
 		"@radix-ui/react-dropdown-menu": "^2.1.16",
@@ -89,12 +85,8 @@
 		"class-variance-authority": "^0.7.1",
 		"clsx": "^2.1.1",
 		"deepagents": "^1.10.5",
-		"emoji-picker-react": "^4.18.0",
-		"fix-webm-duration": "^1.0.6",
 		"gif.js": "^0.2.0",
-		"gsap": "^3.15.0",
 		"langchain": "^1.2.39",
-		"langsmith": "^0.7.1",
 		"lucide-react": "^0.545.0",
 		"mediabunny": "^1.40.1",
 		"motion": "^12.38.0",
diff --git a/poc-d3d/compositor-view-napi/src/lib.rs b/poc-d3d/compositor-view-napi/src/lib.rs
index 5704bbb19b..41e0978a30 100644
--- a/poc-d3d/compositor-view-napi/src/lib.rs
+++ b/poc-d3d/compositor-view-napi/src/lib.rs
@@ -10,7 +10,6 @@ use napi::threadsafe_function::{ErrorStrategy, ThreadsafeFunction, ThreadsafeFun
 use napi::{Env, JsFunction, Task};
 use napi_derive::napi;
 use poc_d3d::compositor::{live_params_from_scene, Compositor};
-use poc_d3d::cursor::CursorTrack;
 use poc_d3d::d3d::Gpu;
 use poc_d3d::live::{LiveView, PausedPreviews};
 use poc_d3d::scene::Scene;
@@ -38,14 +37,6 @@ fn registry() -> &'static Mutex<HashMap<i32, LiveView>> {
     REGISTRY.get_or_init(|| Mutex::new(HashMap::new()))
 }
 
-/// Répertoire fixture (POC) : env `OPENSCREEN_COMPOSITOR_FIXTURE`, sinon défaut local.
-/// Le Lot 3 fournira les vraies sources ; ici on prouve l'embed avec la fixture.
-fn fixture_dir() -> String {
-    std::env::var("OPENSCREEN_COMPOSITOR_FIXTURE").unwrap_or_else(|_| {
-        r"C:\Users\camil\Documents\repos\openscreen\.claude\worktrees\prerelease-version-tag-ee96ae\poc-d3d\fixture".to_string()
-    })
-}
-
 /// Crée une vue **offscreen** (pas de HWND, pas de fenêtre native). Démarre juste
 /// un thread de rendu qui compose chaque frame, blit-resize vers `rect.width`×
 /// `rect.height` (réutilise le même `ensure_resize_target`/`blit_resized` que
@@ -53,10 +44,9 @@ fn fixture_dir() -> String {
 /// `Map`/`Unmap` et stocke un `Vec<u8>` RGBA8 tightly-packed dans la vue pour
 /// que `read_frame` le retourne à la glue TS.
 ///
-/// Si `screen_path`/`webcam_path` sont fournis (F3 : le vrai enregistrement de
-/// l'app — deux fichiers H264 séparés), on rend ces sources ; sinon on retombe
-/// sur la fixture POC. `cursor_path` optionnel (télémétrie curseur ; absent →
-/// pas de curseur).
+/// `screen_path` est requis (F3 : le vrai enregistrement de l'app — deux
+/// fichiers H264 séparés). `webcam_path`/`cursor_path` sont optionnels
+/// (absents → pas de caméra / pas de curseur).
 ///
 /// `rect` ne sert plus que pour `width`/`height` (résolution cible du preview) ;
 /// `x`/`y` sont ignorés (compat structurelle — la position est gérée par CSS).
@@ -67,10 +57,10 @@ pub fn create_view(
     webcam_path: Option<String>,
     cursor_path: Option<String>,
 ) -> Result<i32> {
-    let dir = fixture_dir();
-    let screen = screen_path.unwrap_or_else(|| format!("{dir}/screen.mp4"));
-    let webcam = webcam_path.unwrap_or_else(|| format!("{dir}/webcam.mp4"));
-    let cursor = cursor_path.unwrap_or_else(|| format!("{dir}/screen.cursor.json"));
+    let screen = screen_path
+        .ok_or_else(|| Error::from_reason("create_view: screen_path is required"))?;
+    let webcam = webcam_path.unwrap_or_default();
+    let cursor = cursor_path.unwrap_or_default();
     let view = LiveView::create(
         rect.width.max(1) as u32,
         rect.height.max(1) as u32,
@@ -237,14 +227,6 @@ pub struct ExportStats {
     pub video_duration_s: f64,
 }
 
-/// Export mesuré, exécuté sur un thread worker libuv (l'UI n'est pas bloquée ; la mesure
-/// reste enveloppante dans `run_composited`). Config = C8 (tous effets), pour comparer
-/// directement au bench headless. Le device/compositeur/encodeur vivent sur ce thread.
-pub struct ExportTask {
-    out_path: String,
-    on_progress: Option<ThreadsafeFunction<u32, ErrorStrategy::Fatal>>,
-}
-
 /// Builds a `progress: &mut dyn FnMut(u64)` closure (the shape both `run_composited` and
 /// `run_composited_multi` already call once per encoded frame, for free — measured to not
 /// affect the C8 benchmark's fps) that forwards to `tsfn`, throttled to ~10/s. Encoding at
@@ -296,40 +278,6 @@ impl Drop for PreviewPause {
     }
 }
 
-impl Task for ExportTask {
-    type Output = (u32, f64, f64, f64);
-    type JsValue = ExportStats;
-
-    fn compute(&mut self) -> Result<Self::Output> {
-        // Previews paused for the whole render (GPU 3D engine freed) and put back exactly as
-        // found when this guard drops — including on the error paths below.
-        let _previews = PreviewPause::begin();
-        let dir = fixture_dir();
-        let gpu = Gpu::create(false).map_err(|e| Error::from_reason(format!("{e:#}")))?;
-        let comp = Compositor::new(&gpu).map_err(|e| Error::from_reason(format!("{e:#}")))?;
-        if let Ok(t) = CursorTrack::load(&format!("{dir}/screen.cursor.json"), 100_000.0, 6.0) {
-            comp.set_cursor(t);
-        }
-        let cfg = config::all().pop().expect("au moins une config"); // C8
-        let mut progress = throttled_progress(self.on_progress.take());
-        let s = pipeline::run_composited(
-            &format!("{dir}/screen.mp4"),
-            &format!("{dir}/webcam.mp4"),
-            &self.out_path,
-            &gpu,
-            &comp,
-            &cfg,
-            &mut progress,
-        )
-        .map_err(|e| Error::from_reason(format!("{e:#}")))?;
-        Ok((s.frames as u32, s.wall_s, s.fps, s.video_duration_s))
-    }
-
-    fn resolve(&mut self, _env: Env, out: Self::Output) -> Result<Self::JsValue> {
-        Ok(ExportStats { frames: out.0, wall_s: out.1, fps: out.2, video_duration_s: out.3 })
-    }
-}
-
 /// Convertit une fonction JS optionnelle en `ThreadsafeFunction` appelable depuis le thread
 /// libuv qui exécute `Task::compute` — c'est la seule façon de rappeler JS depuis là. Chaque
 /// appel transporte juste le nombre de frames encodées (`u32`) ; le JS connaît déjà le total
@@ -341,13 +289,6 @@ fn make_progress_tsfn(
         .transpose()
 }
 
-/// Lance un export natif (fixture → MP4, C8) et résout `Promise<ExportStats>`.
-/// `on_progress(framesEncodées)` optionnel — rappelé côté JS à ~10 Hz max pendant le rendu.
-#[napi]
-pub fn export(out_path: String, on_progress: Option<JsFunction>) -> Result<AsyncTask<ExportTask>> {
-    Ok(AsyncTask::new(ExportTask { out_path, on_progress: make_progress_tsfn(on_progress)? }))
-}
-
 /// Un clip de la timeline pour l'export multiclip (JS : camelCase).
 #[napi(object)]
 pub struct ClipInput {
@@ -393,7 +334,8 @@ impl Task for ExportMultiTask {
     type JsValue = ExportStats;
 
     fn compute(&mut self) -> Result<Self::Output> {
-        // See `ExportTask::compute` — same pause-and-restore contract, same guard.
+        // Previews paused for the whole render (GPU 3D engine freed) and restored
+        // exactly as found when this guard drops, including on the error paths.
         let _previews = PreviewPause::begin();
         let gpu = Gpu::create(false).map_err(|e| Error::from_reason(format!("{e:#}")))?;
         let mut cfg = config::all().pop().expect("au moins une config"); // C8
diff --git a/poc-d3d/spikes/build_nv12.bat b/poc-d3d/spikes/build_nv12.bat
deleted file mode 100644
index f4007aa6c6..0000000000
--- a/poc-d3d/spikes/build_nv12.bat
+++ /dev/null
@@ -1,5 +0,0 @@
-@echo off
-call "C:\Program Files\Microsoft Visual Studio\18\Insiders\VC\Auxiliary\Build\vcvars64.bat" >nul 2>&1
-cd /d "%~dp0"
-cl /nologo /EHsc nv12_probe.cpp /Fe:nv12_probe.exe >nv12_build.log 2>&1 || (type nv12_build.log & exit /b 1)
-nv12_probe.exe
diff --git a/poc-d3d/spikes/build_run_d2d.bat b/poc-d3d/spikes/build_run_d2d.bat
deleted file mode 100644
index cd94628760..0000000000
--- a/poc-d3d/spikes/build_run_d2d.bat
+++ /dev/null
@@ -1,11 +0,0 @@
-@echo off
-call "C:\Program Files\Microsoft Visual Studio\18\Insiders\VC\Auxiliary\Build\vcvars64.bat" >nul 2>&1
-cd /d "%~dp0"
-cl /nologo /EHsc /O2 d2d_probe.cpp /Fe:d2d_probe.exe >build.log 2>&1
-if errorlevel 1 (
-  echo BUILD_FAILED
-  type build.log
-  exit /b 1
-)
-echo BUILD_OK
-d2d_probe.exe
diff --git a/poc-d3d/spikes/d2d_probe.cpp b/poc-d3d/spikes/d2d_probe.cpp
deleted file mode 100644
index 1af5c2aebd..0000000000
--- a/poc-d3d/spikes/d2d_probe.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-// S0 spike — Direct2D as a "remove work" candidate (§3).
-// Questions tranchées :
-//   K2  : un ID2D1Device se crée-t-il sur le MÊME ID3D11Device (interop sans copie) ?
-//   E3  : l'effet natif Gaussian Blur floute-t-il réellement une texture D3D11 ?
-//   E4  : l'effet natif Shadow produit-il une ombre portée ?
-// Sortie : lignes RESULT: k=v, lisibles par le runner.
-#include <d3d11.h>
-#include <dxgi1_2.h>
-#include <d2d1_1.h>
-#include <d2d1effects.h>
-#include <d2d1effects_2.h>   // CLSID_D2D1YCbCr (NV12 -> RGB)
-#include <cstdio>
-#include <cmath>
-#include <vector>
-#pragma comment(lib,"d3d11.lib")
-#pragma comment(lib,"d2d1.lib")
-#pragma comment(lib,"dxgi.lib")
-#pragma comment(lib,"dxguid.lib")  // CLSID_D2D1GaussianBlur / CLSID_D2D1Shadow
-
-#define CK(hr,msg) do{ HRESULT _h=(hr); if(FAILED(_h)){ printf("RESULT: fail=%s hr=0x%08lX\n",msg,(unsigned long)_h); return 1913; } }while(0)
-
-static const UINT W=512,H=512;
-
-// netteté = gradient horizontal moyen du canal vert (BGRA)
-static double sharpness(const std::vector<unsigned char>& px, UINT pitch){
-    double acc=0; UINT n=0;
-    for(UINT y=0;y<H;++y){
-        const unsigned char* row=px.data()+y*pitch;
-        for(UINT x=1;x<W;++x){ acc+=std::abs((int)row[x*4+1]-(int)row[(x-1)*4+1]); ++n; }
-    }
-    return n?acc/n:0;
-}
-
-int main(){
-    // --- D3D11 device (BGRA requis par D2D), feature level 11_1 comme le §2 ---
-    D3D_FEATURE_LEVEL want[]={D3D_FEATURE_LEVEL_11_1};
-    ID3D11Device* dev=nullptr; ID3D11DeviceContext* ctx3d=nullptr; D3D_FEATURE_LEVEL got{};
-    CK(D3D11CreateDevice(nullptr,D3D_DRIVER_TYPE_HARDWARE,nullptr,
-        D3D11_CREATE_DEVICE_BGRA_SUPPORT,want,1,D3D11_SDK_VERSION,&dev,&got,&ctx3d),"d3d11_create");
-    printf("RESULT: d3d11_device=ok feature_level=0x%X\n",(unsigned)got);
-
-    // --- K2 : D2D device sur le MÊME device via son IDXGIDevice ---
-    IDXGIDevice* dxgi=nullptr; CK(dev->QueryInterface(__uuidof(IDXGIDevice),(void**)&dxgi),"qi_dxgi");
-    ID2D1Device* d2dDev=nullptr;
-    CK(D2D1CreateDevice(dxgi,nullptr,&d2dDev),"d2d_create_device");
-    ID2D1DeviceContext* dc=nullptr;
-    CK(d2dDev->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE,&dc),"d2d_ctx");
-    printf("RESULT: k2_d2d_shares_d3d11_device=ok\n");
-
-    // --- texture source : rayures verticales 2px (gradient max) ---
-    std::vector<unsigned char> src(W*H*4);
-    for(UINT y=0;y<H;++y)for(UINT x=0;x<W;++x){
-        unsigned char v=((x/2)&1)?255:0; size_t o=(y*W+x)*4;
-        src[o]=v;src[o+1]=v;src[o+2]=v;src[o+3]=255;
-    }
-    D3D11_TEXTURE2D_DESC td{}; td.Width=W;td.Height=H;td.MipLevels=1;td.ArraySize=1;
-    td.Format=DXGI_FORMAT_B8G8R8A8_UNORM;td.SampleDesc.Count=1;td.Usage=D3D11_USAGE_DEFAULT;
-    td.BindFlags=D3D11_BIND_SHADER_RESOURCE;
-    D3D11_SUBRESOURCE_DATA sd{}; sd.pSysMem=src.data(); sd.SysMemPitch=W*4;
-    ID3D11Texture2D* srcTex=nullptr; CK(dev->CreateTexture2D(&td,&sd,&srcTex),"src_tex");
-
-    // wrap D3D11 -> D2D bitmap (zéro copie : même surface DXGI)
-    IDXGISurface* srcSurf=nullptr; CK(srcTex->QueryInterface(__uuidof(IDXGISurface),(void**)&srcSurf),"src_surf");
-    D2D1_BITMAP_PROPERTIES1 bp=D2D1::BitmapProperties1(
-        D2D1_BITMAP_OPTIONS_NONE,
-        D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM,D2D1_ALPHA_MODE_PREMULTIPLIED));
-    ID2D1Bitmap1* srcBmp=nullptr; CK(dc->CreateBitmapFromDxgiSurface(srcSurf,&bp,&srcBmp),"src_bmp");
-
-    // --- cible : texture render-target, wrap en bitmap TARGET ---
-    D3D11_TEXTURE2D_DESC tt=td; tt.BindFlags=D3D11_BIND_RENDER_TARGET|D3D11_BIND_SHADER_RESOURCE;
-    ID3D11Texture2D* dstTex=nullptr; CK(dev->CreateTexture2D(&tt,nullptr,&dstTex),"dst_tex");
-    IDXGISurface* dstSurf=nullptr; CK(dstTex->QueryInterface(__uuidof(IDXGISurface),(void**)&dstSurf),"dst_surf");
-    D2D1_BITMAP_PROPERTIES1 tp=D2D1::BitmapProperties1(
-        D2D1_BITMAP_OPTIONS_TARGET,
-        D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM,D2D1_ALPHA_MODE_PREMULTIPLIED));
-    ID2D1Bitmap1* dstBmp=nullptr; CK(dc->CreateBitmapFromDxgiSurface(dstSurf,&tp,&dstBmp),"dst_bmp");
-
-    // staging pour relire
-    D3D11_TEXTURE2D_DESC stg=td; stg.Usage=D3D11_USAGE_STAGING; stg.BindFlags=0;
-    stg.CPUAccessFlags=D3D11_CPU_ACCESS_READ;
-    ID3D11Texture2D* stgTex=nullptr; CK(dev->CreateTexture2D(&stg,nullptr,&stgTex),"stg_tex");
-
-    auto readback=[&](const char* tag)->double{
-        ctx3d->CopyResource(stgTex,dstTex); ctx3d->Flush();
-        D3D11_MAPPED_SUBRESOURCE m{}; CK(ctx3d->Map(stgTex,0,D3D11_MAP_READ,0,&m),"map");
-        std::vector<unsigned char> out(m.RowPitch*H);
-        memcpy(out.data(),m.pData,out.size());
-        ctx3d->Unmap(stgTex,0);
-        return sharpness(out,m.RowPitch);
-    };
-
-    double sharp_src=sharpness(src,W*4);
-    printf("RESULT: sharp_source=%.2f\n",sharp_src);
-
-    // --- E3 : Gaussian Blur natif ---
-    {
-        ID2D1Effect* blur=nullptr; CK(dc->CreateEffect(CLSID_D2D1GaussianBlur,&blur),"blur_effect");
-        blur->SetInput(0,srcBmp);
-        CK(blur->SetValue(D2D1_GAUSSIANBLUR_PROP_STANDARD_DEVIATION,12.0f),"blur_sigma");
-        dc->SetTarget(dstBmp); dc->BeginDraw();
-        dc->Clear(D2D1::ColorF(0,0,0,1));
-        dc->DrawImage(blur);
-        CK(dc->EndDraw(),"blur_enddraw");
-        double s=readback("blur");
-        printf("RESULT: e3_gaussian_blur=ok sharp_after=%.2f ratio=%.3f\n",s,s/sharp_src);
-        blur->Release();
-    }
-    // --- E4 : Shadow natif (source opaque -> ombre décalée sur fond) ---
-    {
-        ID2D1Effect* shadow=nullptr;
-        HRESULT hs=dc->CreateEffect(CLSID_D2D1Shadow,&shadow);
-        if(SUCCEEDED(hs)){
-            shadow->SetInput(0,srcBmp);
-            shadow->SetValue(D2D1_SHADOW_PROP_BLUR_STANDARD_DEVIATION,8.0f);
-            dc->SetTarget(dstBmp); dc->BeginDraw();
-            dc->Clear(D2D1::ColorF(1,1,1,1));
-            dc->DrawImage(shadow);
-            HRESULT he=dc->EndDraw();
-            printf("RESULT: e4_shadow=%s\n",SUCCEEDED(he)?"ok":"draw_fail");
-            shadow->Release();
-        } else {
-            printf("RESULT: e4_shadow=create_fail hr=0x%08lX\n",(unsigned long)hs);
-        }
-    }
-    // --- K2 réel : le décodeur sort du NV12. D2D peut-il l'emballer directement ? ---
-    {
-        D3D11_TEXTURE2D_DESC nd{}; nd.Width=W; nd.Height=H; nd.MipLevels=1; nd.ArraySize=1;
-        nd.Format=DXGI_FORMAT_NV12; nd.SampleDesc.Count=1; nd.Usage=D3D11_USAGE_DEFAULT;
-        nd.BindFlags=D3D11_BIND_SHADER_RESOURCE;
-        // NV12 : plan Y (W*H) puis plan UV entrelacé (W*H/2)
-        std::vector<unsigned char> nv12(W*H + W*H/2, 128);
-        for(UINT y=0;y<H;++y)for(UINT x=0;x<W;++x) nv12[y*W+x]=((x/2)&1)?235:16;
-        D3D11_SUBRESOURCE_DATA nsd{}; nsd.pSysMem=nv12.data(); nsd.SysMemPitch=W;
-        ID3D11Texture2D* nvTex=nullptr;
-        HRESULT hn=dev->CreateTexture2D(&nd,&nsd,&nvTex);
-        if(FAILED(hn)){ printf("RESULT: nv12_texture=fail hr=0x%08lX\n",(unsigned long)hn); }
-        else {
-            IDXGISurface* nvSurf=nullptr; nvTex->QueryInterface(__uuidof(IDXGISurface),(void**)&nvSurf);
-            D2D1_BITMAP_PROPERTIES1 np=D2D1::BitmapProperties1(
-                D2D1_BITMAP_OPTIONS_NONE,
-                D2D1::PixelFormat(DXGI_FORMAT_NV12,D2D1_ALPHA_MODE_IGNORE));
-            ID2D1Bitmap1* nvBmp=nullptr;
-            HRESULT hb=dc->CreateBitmapFromDxgiSurface(nvSurf,&np,&nvBmp);
-            if(FAILED(hb)){ printf("RESULT: nv12_as_d2d_bitmap=fail hr=0x%08lX\n",(unsigned long)hb); }
-            else {
-                // effet YCbCr natif = conversion NV12->RGB (E1) sans shader maison
-                ID2D1Effect* ycbcr=nullptr;
-                HRESULT hy=dc->CreateEffect(CLSID_D2D1YCbCr,&ycbcr);
-                if(SUCCEEDED(hy)){
-                    ycbcr->SetInput(0,nvBmp);
-                    dc->SetTarget(dstBmp); dc->BeginDraw(); dc->Clear(D2D1::ColorF(0,0,0,1));
-                    dc->DrawImage(ycbcr); HRESULT he=dc->EndDraw();
-                    printf("RESULT: nv12_ingest=ok e1_ycbcr_effect=%s\n",SUCCEEDED(he)?"ok":"draw_fail");
-                    ycbcr->Release();
-                } else printf("RESULT: nv12_ingest=ok e1_ycbcr_effect=create_fail hr=0x%08lX\n",(unsigned long)hy);
-                nvBmp->Release();
-            }
-            if(nvSurf)nvSurf->Release(); nvTex->Release();
-        }
-    }
-    printf("RESULT: done=ok\n");
-    return 0;
-}
diff --git a/poc-d3d/spikes/nv12_probe.cpp b/poc-d3d/spikes/nv12_probe.cpp
deleted file mode 100644
index 1be94106cc..0000000000
--- a/poc-d3d/spikes/nv12_probe.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <d3d11.h>
-#include <cstdio>
-#pragma comment(lib,"d3d11.lib")
-int main(){
-    ID3D11Device* dev=nullptr; ID3D11DeviceContext* ctx=nullptr;
-    D3D_FEATURE_LEVEL fl=D3D_FEATURE_LEVEL_11_1;
-    D3D11CreateDevice(nullptr,D3D_DRIVER_TYPE_HARDWARE,nullptr,
-        D3D11_CREATE_DEVICE_VIDEO_SUPPORT,&fl,1,D3D11_SDK_VERSION,&dev,nullptr,&ctx);
-    UINT s=0; dev->CheckFormatSupport(DXGI_FORMAT_NV12,&s);
-    printf("NV12 support flags=0x%X\n", s);
-    printf("  TEXTURE2D      : %d\n", !!(s & D3D11_FORMAT_SUPPORT_TEXTURE2D));
-    printf("  SHADER_SAMPLE  : %d\n", !!(s & D3D11_FORMAT_SUPPORT_SHADER_SAMPLE));
-    printf("  RENDER_TARGET  : %d\n", !!(s & D3D11_FORMAT_SUPPORT_RENDER_TARGET));
-    printf("  DECODER_OUTPUT : %d\n", !!(s & D3D11_FORMAT_SUPPORT_DECODER_OUTPUT));
-    // try actually creating an NV12 texture ARRAY with RENDER_TARGET|SHADER_RESOURCE
-    D3D11_TEXTURE2D_DESC td{}; td.Width=1920;td.Height=1080;td.MipLevels=1;td.ArraySize=8;
-    td.Format=DXGI_FORMAT_NV12;td.SampleDesc.Count=1;td.Usage=D3D11_USAGE_DEFAULT;
-    td.BindFlags=D3D11_BIND_RENDER_TARGET|D3D11_BIND_SHADER_RESOURCE;
-    ID3D11Texture2D* t=nullptr;
-    HRESULT h=dev->CreateTexture2D(&td,nullptr,&t);
-    printf("create NV12 array[8] RT|SR : hr=0x%08lX %s\n",(unsigned long)h, SUCCEEDED(h)?"OK":"FAIL");
-    if(t){t->Release();t=nullptr;}
-    td.BindFlags=D3D11_BIND_RENDER_TARGET;
-    h=dev->CreateTexture2D(&td,nullptr,&t);
-    printf("create NV12 array[8] RT only: hr=0x%08lX %s\n",(unsigned long)h, SUCCEEDED(h)?"OK":"FAIL");
-    if(t){t->Release();t=nullptr;}
-    // single (non-array) NV12 RT
-    td.ArraySize=1; td.BindFlags=D3D11_BIND_RENDER_TARGET|D3D11_BIND_SHADER_RESOURCE;
-    h=dev->CreateTexture2D(&td,nullptr,&t);
-    printf("create NV12 single  RT|SR : hr=0x%08lX %s\n",(unsigned long)h, SUCCEEDED(h)?"OK":"FAIL");
-    return 0;
-}
diff --git a/poc-native/.gitignore b/poc-native/.gitignore
deleted file mode 100644
index 4a95ed4ffa..0000000000
--- a/poc-native/.gitignore
+++ /dev/null
@@ -1,7 +0,0 @@
-/target
-*.rgba
-*.bmp
-out-preview.png
-out.mp4
-/ffmpeg-dev
-out*.mp4
diff --git a/poc-native/Cargo.lock b/poc-native/Cargo.lock
deleted file mode 100644
index 3baa1f1d8a..0000000000
--- a/poc-native/Cargo.lock
+++ /dev/null
@@ -1,1657 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "aho-corasick"
-version = "1.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "allocator-api2"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
-
-[[package]]
-name = "android_system_properties"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "arrayvec"
-version = "0.7.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
-
-[[package]]
-name = "ash"
-version = "0.38.0+1.3.281"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f"
-dependencies = [
- "libloading",
-]
-
-[[package]]
-name = "autocfg"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
-
-[[package]]
-name = "bindgen"
-version = "0.72.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
-dependencies = [
- "bitflags",
- "cexpr",
- "clang-sys",
- "itertools",
- "proc-macro2",
- "quote",
- "regex",
- "rustc-hash 2.1.3",
- "shlex 1.3.0",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "bit-set"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34ddef2995421ab6a5c779542c81ee77c115206f4ad9d5a8e05f4ff49716a3dd"
-dependencies = [
- "bit-vec",
-]
-
-[[package]]
-name = "bit-vec"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
-
-[[package]]
-name = "bitflags"
-version = "2.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
-
-[[package]]
-name = "bitstream-io"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6099cdc01846bc367c4e7dd630dc5966dccf36b652fae7a74e17b640411a91b2"
-
-[[package]]
-name = "block2"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
-dependencies = [
- "objc2",
-]
-
-[[package]]
-name = "bumpalo"
-version = "3.20.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
-
-[[package]]
-name = "bytemuck"
-version = "1.25.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6aedf8ae72766347502cf3cb4f41cf5e9cc37d28bee90f1fdaaae15f9cf9424"
-dependencies = [
- "bytemuck_derive",
-]
-
-[[package]]
-name = "bytemuck_derive"
-version = "1.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f65693059b6b9c588b9f62fed1cedbf0a8b805631457ea162d68f0de186f3de5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "bytes"
-version = "1.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
-
-[[package]]
-name = "cc"
-version = "1.2.67"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e17dd265a7d0f31ef544e1b20e03add05d3b45b491b633b10d67145d2acc1a38"
-dependencies = [
- "find-msvc-tools",
- "shlex 2.0.1",
-]
-
-[[package]]
-name = "cexpr"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
-dependencies = [
- "nom",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
-
-[[package]]
-name = "cfg_aliases"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
-
-[[package]]
-name = "clang-sys"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
-dependencies = [
- "glob",
- "libc",
- "libloading",
-]
-
-[[package]]
-name = "codespan-reporting"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681"
-dependencies = [
- "serde",
- "termcolor",
- "unicode-width",
-]
-
-[[package]]
-name = "crunchy"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
-
-[[package]]
-name = "derivative"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "dispatch2"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
-dependencies = [
- "bitflags",
- "objc2",
-]
-
-[[package]]
-name = "dlib"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a"
-dependencies = [
- "libloading",
-]
-
-[[package]]
-name = "document-features"
-version = "0.2.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
-dependencies = [
- "litrs",
-]
-
-[[package]]
-name = "either"
-version = "1.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
-
-[[package]]
-name = "equivalent"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
-
-[[package]]
-name = "ffmpeg-next"
-version = "8.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7c4bd5ab1ac61f29c634df1175d350ded29cf74c3c6d4f7030431a5ae3c7d5d"
-dependencies = [
- "bitflags",
- "ffmpeg-sys-next",
- "libc",
-]
-
-[[package]]
-name = "ffmpeg-sys-next"
-version = "8.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a314bc0e022a33a99567ed4bd2576bd58ffd8fcff7891c29194cfecc26a62547"
-dependencies = [
- "bindgen",
- "cc",
- "libc",
- "num_cpus",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "find-msvc-tools"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
-
-[[package]]
-name = "foldhash"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
-
-[[package]]
-name = "foldhash"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
-
-[[package]]
-name = "four-cc"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "795cbfc56d419a7ce47ccbb7504dd9a5b7c484c083c356e797de08bd988d9629"
-
-[[package]]
-name = "futures-core"
-version = "0.3.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
-
-[[package]]
-name = "futures-task"
-version = "0.3.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
-
-[[package]]
-name = "futures-util"
-version = "0.3.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
-dependencies = [
- "futures-core",
- "futures-task",
- "pin-project-lite",
- "slab",
-]
-
-[[package]]
-name = "gl_generator"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d"
-dependencies = [
- "khronos_api",
- "log",
- "xml-rs",
-]
-
-[[package]]
-name = "glob"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
-
-[[package]]
-name = "glow"
-version = "0.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29038e1c483364cc6bb3cf78feee1816002e127c331a1eec55a4d202b9e1adb5"
-dependencies = [
- "js-sys",
- "slotmap",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "glutin_wgl_sys"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c4ee00b289aba7a9e5306d57c2d05499b2e5dc427f84ac708bd2c090212cf3e"
-dependencies = [
- "gl_generator",
-]
-
-[[package]]
-name = "gpu-allocator"
-version = "0.28.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51255ea7cfaadb6c5f1528d43e92a82acb2b96c43365989a28b2d44ee38f8795"
-dependencies = [
- "ash",
- "hashbrown 0.16.1",
- "log",
- "presser",
- "thiserror 2.0.18",
- "windows",
-]
-
-[[package]]
-name = "gpu-descriptor"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b89c83349105e3732062a895becfc71a8f921bb71ecbbdd8ff99263e3b53a0ca"
-dependencies = [
- "bitflags",
- "gpu-descriptor-types",
- "hashbrown 0.15.5",
-]
-
-[[package]]
-name = "gpu-descriptor-types"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "gpu-video"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cef89763e3504bd4ebfd96335863dcbc1e81f02623cfd3001712a2c015aa80c4"
-dependencies = [
- "ash",
- "bytemuck",
- "bytes",
- "cfg_aliases",
- "derivative",
- "h264-reader",
- "memchr",
- "rustc-hash 2.1.3",
- "thiserror 1.0.69",
- "tracing",
- "vk-mem",
- "wgpu",
-]
-
-[[package]]
-name = "h264-reader"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "036a78b2620d92f0ec57690bc792b3bb87348632ee5225302ba2e66a48021c6c"
-dependencies = [
- "bitstream-io",
- "hex-slice",
- "log",
- "memchr",
- "rfc6381-codec",
-]
-
-[[package]]
-name = "half"
-version = "2.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
-dependencies = [
- "cfg-if",
- "crunchy",
- "num-traits",
- "zerocopy",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.15.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
-dependencies = [
- "foldhash 0.1.5",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.16.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
-dependencies = [
- "allocator-api2",
- "equivalent",
- "foldhash 0.2.0",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.17.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
-
-[[package]]
-name = "hermit-abi"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
-
-[[package]]
-name = "hex-slice"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5491a308e0214554f07a81d8944abe45f552871c12e3c3c6e7e5d354039a6c4c"
-
-[[package]]
-name = "hexf-parse"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
-
-[[package]]
-name = "indexmap"
-version = "2.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
-dependencies = [
- "equivalent",
- "hashbrown 0.17.1",
-]
-
-[[package]]
-name = "itertools"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "jni-sys"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"
-dependencies = [
- "jni-sys 0.4.1",
-]
-
-[[package]]
-name = "jni-sys"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
-dependencies = [
- "jni-sys-macros",
-]
-
-[[package]]
-name = "jni-sys-macros"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
-dependencies = [
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "js-sys"
-version = "0.3.103"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53b44bfcdb3f8d5837a46dae1ca9660a837176eee74a28b229bc626816589102"
-dependencies = [
- "cfg-if",
- "futures-util",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "khronos-egl"
-version = "6.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76"
-dependencies = [
- "libc",
- "libloading",
- "pkg-config",
-]
-
-[[package]]
-name = "khronos_api"
-version = "3.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
-[[package]]
-name = "libc"
-version = "0.2.186"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
-
-[[package]]
-name = "libloading"
-version = "0.8.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
-dependencies = [
- "cfg-if",
- "windows-link",
-]
-
-[[package]]
-name = "libm"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
-
-[[package]]
-name = "litrs"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
-
-[[package]]
-name = "lock_api"
-version = "0.4.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
-dependencies = [
- "scopeguard",
-]
-
-[[package]]
-name = "log"
-version = "0.4.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
-
-[[package]]
-name = "matchers"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
-dependencies = [
- "regex-automata",
-]
-
-[[package]]
-name = "memchr"
-version = "2.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
-
-[[package]]
-name = "minimal-lexical"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
-
-[[package]]
-name = "mp4ra-rust"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdbc3d3867085d66ac6270482e66f3dd2c5a18451a3dc9ad7269e94844a536b7"
-dependencies = [
- "four-cc",
-]
-
-[[package]]
-name = "mpeg4-audio-const"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96a1fe2275b68991faded2c80aa4a33dba398b77d276038b8f50701a22e55918"
-
-[[package]]
-name = "naga"
-version = "29.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2bf919621e7975acb27d881bae2fb993e0d45c8e0446e85e6272971e00dc8df"
-dependencies = [
- "arrayvec",
- "bit-set",
- "bitflags",
- "cfg-if",
- "cfg_aliases",
- "codespan-reporting",
- "half",
- "hashbrown 0.16.1",
- "hexf-parse",
- "indexmap",
- "libm",
- "log",
- "num-traits",
- "once_cell",
- "rustc-hash 1.1.0",
- "spirv",
- "thiserror 2.0.18",
- "unicode-ident",
-]
-
-[[package]]
-name = "ndk-sys"
-version = "0.6.0+11769913"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873"
-dependencies = [
- "jni-sys 0.3.1",
-]
-
-[[package]]
-name = "nom"
-version = "7.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
-dependencies = [
- "memchr",
- "minimal-lexical",
-]
-
-[[package]]
-name = "nu-ansi-term"
-version = "0.50.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
-dependencies = [
- "windows-sys",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
-dependencies = [
- "autocfg",
- "libm",
-]
-
-[[package]]
-name = "num_cpus"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
-dependencies = [
- "hermit-abi",
- "libc",
-]
-
-[[package]]
-name = "objc2"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
-dependencies = [
- "objc2-encode",
-]
-
-[[package]]
-name = "objc2-core-foundation"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
-dependencies = [
- "bitflags",
- "dispatch2",
- "objc2",
-]
-
-[[package]]
-name = "objc2-encode"
-version = "4.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
-
-[[package]]
-name = "objc2-foundation"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
-dependencies = [
- "bitflags",
- "objc2",
- "objc2-core-foundation",
-]
-
-[[package]]
-name = "objc2-metal"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794"
-dependencies = [
- "bitflags",
- "block2",
- "objc2",
- "objc2-foundation",
-]
-
-[[package]]
-name = "objc2-quartz-core"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
-dependencies = [
- "bitflags",
- "objc2",
- "objc2-core-foundation",
- "objc2-foundation",
- "objc2-metal",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.21.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
-
-[[package]]
-name = "ordered-float"
-version = "5.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7d950ca161dc355eaf28f82b11345ed76c6e1f6eb1f4f4479e0323b9e2fbd0e"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "parking_lot"
-version = "0.12.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-link",
-]
-
-[[package]]
-name = "pin-project-lite"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
-
-[[package]]
-name = "pkg-config"
-version = "0.3.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
-
-[[package]]
-name = "poc-native"
-version = "0.1.0"
-dependencies = [
- "bytemuck",
- "ffmpeg-next",
- "gpu-video",
- "pollster",
- "tracing-subscriber",
- "wgpu",
-]
-
-[[package]]
-name = "pollster"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22686f4785f02a4fcc856d3b3bb19bf6c8160d103f7a99cc258bddd0251dc7f2"
-
-[[package]]
-name = "portable-atomic"
-version = "1.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d20d5497ef88037a52ff98267d066e7f11fcc5e99bbfbd58a42336193aacec3"
-
-[[package]]
-name = "portable-atomic-util"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618"
-dependencies = [
- "portable-atomic",
-]
-
-[[package]]
-name = "presser"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "profiling"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"
-
-[[package]]
-name = "quote"
-version = "1.0.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "range-alloc"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08"
-
-[[package]]
-name = "raw-window-handle"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
-
-[[package]]
-name = "raw-window-metal"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40d213455a5f1dc59214213c7330e074ddf8114c9a42411eb890c767357ce135"
-dependencies = [
- "objc2",
- "objc2-core-foundation",
- "objc2-foundation",
- "objc2-quartz-core",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.5.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "regex"
-version = "1.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fcfdb36bda0c880c5931cdc7a2bcdc8ba4556847b9d912bca70bc94708711ad"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
-
-[[package]]
-name = "renderdoc-sys"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832"
-
-[[package]]
-name = "rfc6381-codec"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed54c20f5c3ec82eab6d998b313dc75ec5d5650d4f57675e61d72489040297fd"
-dependencies = [
- "mp4ra-rust",
- "mpeg4-audio-const",
-]
-
-[[package]]
-name = "rustc-hash"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
-
-[[package]]
-name = "rustc-hash"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
-
-[[package]]
-name = "rustversion"
-version = "1.0.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
-
-[[package]]
-name = "scopeguard"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
-
-[[package]]
-name = "serde"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
-dependencies = [
- "serde_core",
- "serde_derive",
-]
-
-[[package]]
-name = "serde_core"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "sharded-slab"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
-dependencies = [
- "lazy_static",
-]
-
-[[package]]
-name = "shlex"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
-
-[[package]]
-name = "shlex"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
-
-[[package]]
-name = "slab"
-version = "0.4.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
-
-[[package]]
-name = "slotmap"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038"
-dependencies = [
- "version_check",
-]
-
-[[package]]
-name = "smallvec"
-version = "1.15.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
-
-[[package]]
-name = "spirv"
-version = "0.4.0+sdk-1.4.341.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9571ea910ebd84c86af4b3ed27f9dbdc6ad06f17c5f96146b2b671e2976744f"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "syn"
-version = "1.0.109"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.119"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "termcolor"
-version = "1.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
-dependencies = [
- "winapi-util",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
-dependencies = [
- "thiserror-impl 1.0.69",
-]
-
-[[package]]
-name = "thiserror"
-version = "2.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
-dependencies = [
- "thiserror-impl 2.0.18",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "2.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "thread_local"
-version = "1.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad99c4c6d32803332c548b1af0540b357b3f5fc0be8f6c6bfe8b2e6ae784070"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "tracing"
-version = "0.1.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
-dependencies = [
- "pin-project-lite",
- "tracing-attributes",
- "tracing-core",
-]
-
-[[package]]
-name = "tracing-attributes"
-version = "0.1.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "tracing-core"
-version = "0.1.36"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
-dependencies = [
- "once_cell",
- "valuable",
-]
-
-[[package]]
-name = "tracing-log"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
-dependencies = [
- "log",
- "once_cell",
- "tracing-core",
-]
-
-[[package]]
-name = "tracing-subscriber"
-version = "0.3.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
-dependencies = [
- "matchers",
- "nu-ansi-term",
- "once_cell",
- "regex-automata",
- "sharded-slab",
- "smallvec",
- "thread_local",
- "tracing",
- "tracing-core",
- "tracing-log",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
-
-[[package]]
-name = "unicode-width"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
-
-[[package]]
-name = "valuable"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
-
-[[package]]
-name = "vcpkg"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
-
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
-name = "vk-mem"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cb12b79bcec57a3334d0284f1364c1846f378bb47df9779c6dbfcfc245c9404"
-dependencies = [
- "ash",
- "bitflags",
- "cc",
-]
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.126"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b067c0c11094aef6b7a801c1e34a26affafdf3d051dba08456b868789aaf9a4"
-dependencies = [
- "cfg-if",
- "once_cell",
- "rustversion",
- "wasm-bindgen-macro",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-futures"
-version = "0.4.76"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c62df1340f32221cb9c54d6a27b030e3dba64361d4a95bed55f9aacb44da291d"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.126"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.126"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e"
-dependencies = [
- "bumpalo",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.126"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc1b4cb0cc549fcf58d7dfc081778139b3d283a081644e833e84682ad71cea24"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "wayland-sys"
-version = "0.31.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be"
-dependencies = [
- "dlib",
- "log",
- "once_cell",
- "pkg-config",
-]
-
-[[package]]
-name = "web-sys"
-version = "0.3.103"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8622dcb61c0bcc9fffa6938bed81210af2da9a7e4a1a834b2e37a59b6dfb6141"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "wgpu"
-version = "29.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76e8840e1ba2881d4cbb18d2147627a56af426ff064c0401eb0c8410c6325d07"
-dependencies = [
- "arrayvec",
- "bitflags",
- "bytemuck",
- "cfg-if",
- "cfg_aliases",
- "document-features",
- "hashbrown 0.16.1",
- "js-sys",
- "log",
- "naga",
- "parking_lot",
- "portable-atomic",
- "profiling",
- "raw-window-handle",
- "smallvec",
- "static_assertions",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
- "wgpu-core",
- "wgpu-hal",
- "wgpu-types",
-]
-
-[[package]]
-name = "wgpu-core"
-version = "29.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f519832254e56965a9940c4af57dcb75f702b6f6fa4a0b172f685395843a4d7"
-dependencies = [
- "arrayvec",
- "bit-set",
- "bit-vec",
- "bitflags",
- "bytemuck",
- "cfg_aliases",
- "document-features",
- "hashbrown 0.16.1",
- "indexmap",
- "log",
- "naga",
- "once_cell",
- "parking_lot",
- "portable-atomic",
- "profiling",
- "raw-window-handle",
- "rustc-hash 1.1.0",
- "smallvec",
- "thiserror 2.0.18",
- "wgpu-core-deps-apple",
- "wgpu-core-deps-emscripten",
- "wgpu-core-deps-windows-linux-android",
- "wgpu-hal",
- "wgpu-naga-bridge",
- "wgpu-types",
-]
-
-[[package]]
-name = "wgpu-core-deps-apple"
-version = "29.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5e39e26c4c0e07589e67d18546cf79ff45383659fc72fca4dd293358a0347f3"
-dependencies = [
- "wgpu-hal",
-]
-
-[[package]]
-name = "wgpu-core-deps-emscripten"
-version = "29.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01e09be551dc939498bdd5f6b2c66e55ab275dad25825267a08605a80fc9f0af"
-dependencies = [
- "wgpu-hal",
-]
-
-[[package]]
-name = "wgpu-core-deps-windows-linux-android"
-version = "29.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e592c1bbef6ad047647ae6e666ebd8cee7a32bb4544d9700ec96cbf73230257"
-dependencies = [
- "wgpu-hal",
-]
-
-[[package]]
-name = "wgpu-hal"
-version = "29.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97ace1c17727311c22a46e4e3faf56ea6de81af99dcc839bdfb54857b94d448d"
-dependencies = [
- "android_system_properties",
- "arrayvec",
- "ash",
- "bit-set",
- "bitflags",
- "block2",
- "bytemuck",
- "cfg-if",
- "cfg_aliases",
- "glow",
- "glutin_wgl_sys",
- "gpu-allocator",
- "gpu-descriptor",
- "hashbrown 0.16.1",
- "js-sys",
- "khronos-egl",
- "libc",
- "libloading",
- "log",
- "naga",
- "ndk-sys",
- "objc2",
- "objc2-core-foundation",
- "objc2-foundation",
- "objc2-metal",
- "objc2-quartz-core",
- "once_cell",
- "ordered-float",
- "parking_lot",
- "portable-atomic",
- "portable-atomic-util",
- "profiling",
- "range-alloc",
- "raw-window-handle",
- "raw-window-metal",
- "renderdoc-sys",
- "smallvec",
- "thiserror 2.0.18",
- "wasm-bindgen",
- "wayland-sys",
- "web-sys",
- "wgpu-naga-bridge",
- "wgpu-types",
- "windows",
- "windows-core",
- "windows-result",
-]
-
-[[package]]
-name = "wgpu-naga-bridge"
-version = "29.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95226013f547544b223281cd16a4fb549aa9dcb562adbda0faae4c73ffbbc161"
-dependencies = [
- "naga",
- "wgpu-types",
-]
-
-[[package]]
-name = "wgpu-types"
-version = "29.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84bf84cd9ca8ca45e2b223a3868f1adf9bfc0c66aeac212e76ee7e40fdadf8f5"
-dependencies = [
- "bitflags",
- "bytemuck",
- "js-sys",
- "log",
- "raw-window-handle",
- "web-sys",
-]
-
-[[package]]
-name = "winapi-util"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
-dependencies = [
- "windows-sys",
-]
-
-[[package]]
-name = "windows"
-version = "0.62.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
-dependencies = [
- "windows-collections",
- "windows-core",
- "windows-future",
- "windows-numerics",
-]
-
-[[package]]
-name = "windows-collections"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
-dependencies = [
- "windows-core",
-]
-
-[[package]]
-name = "windows-core"
-version = "0.62.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
-dependencies = [
- "windows-implement",
- "windows-interface",
- "windows-link",
- "windows-result",
- "windows-strings",
-]
-
-[[package]]
-name = "windows-future"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
-dependencies = [
- "windows-core",
- "windows-link",
- "windows-threading",
-]
-
-[[package]]
-name = "windows-implement"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "windows-interface"
-version = "0.59.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "windows-link"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
-
-[[package]]
-name = "windows-numerics"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
-dependencies = [
- "windows-core",
- "windows-link",
-]
-
-[[package]]
-name = "windows-result"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "windows-strings"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.61.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "windows-threading"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "xml-rs"
-version = "0.8.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ae8337f8a065cfc972643663ea4279e04e7256de865aa66fe25cec5fb912d3f"
-
-[[package]]
-name = "zerocopy"
-version = "0.8.54"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7cbbc0a705a0fd05cc3676525980d2bf5a9bc4adac6d6475209a7887cf59d19"
-dependencies = [
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.8.54"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e817b7b52d0c7358d3246da9d69935ebb18116b2b102b4230dac079b4862f5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
diff --git a/poc-native/Cargo.toml b/poc-native/Cargo.toml
deleted file mode 100644
index f9d8f7021d..0000000000
--- a/poc-native/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "poc-native"
-version = "0.1.0"
-edition = "2021"
-
-# Native full-shader compositor POC. No browser, no Electron, no WebCodecs:
-# wgpu runs the same WGSL as the web POC (adapted from texture_external to plain
-# 2D textures, a WebGPU-only feature that native wgpu does not have), and the
-# hardware H.264 encoder is reached natively. This is the "most performant and
-# native possible" path the web POC could not measure.
-
-[dependencies]
-wgpu = "29"
-pollster = "0.3"
-bytemuck = { version = "1", features = ["derive"] }
-ffmpeg-next = "8.1.0"
-gpu-video = "0.4.0"
-tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
-
-[profile.release]
-opt-level = 3
diff --git a/poc-native/src/bin/gpures.rs b/poc-native/src/bin/gpures.rs
deleted file mode 100644
index f4037b985a..0000000000
--- a/poc-native/src/bin/gpures.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-// GPU-resident native pipeline, milestone 1: hardware Vulkan Video decode straight
-// into a wgpu::Texture — no CPU upload, no swscale — via gpu-video. This is the
-// piece the CPU path could never have: decoded frames that never touch RAM.
-//
-// gpu-video owns the wgpu device (it creates the Vulkan device with the video
-// extensions), so the composite pipeline will later be built on ITS device and
-// sample these textures directly. Step 1 just proves the zero-copy decode works
-// on this AMD iGPU (ffmpeg confirmed Vulkan DECODE works here; encode did not).
-
-use ffmpeg_next as ff;
-use gpu_video::parameters as gp;
-
-// mp4 stores H.264 as length-prefixed AVCC NALs; the Vulkan decoder wants Annex-B
-// (start codes) with in-band SPS/PPS. Convert by hand — a bitstream filter in ~40
-// lines, no BSF-API guesswork.
-fn avcc_sps_pps(extradata: &[u8]) -> Vec<u8> {
-    // avcC: [0]=1 [1..4]=profile/compat/level [4]=0xFC|lenSizeMinus1
-    // [5]=0xE0|numSPS, then numSPS x (u16 len + SPS), then numPPS, then PPS...
-    let mut out = Vec::new();
-    if extradata.len() < 6 { return out; }
-    let mut i = 5usize;
-    let num_sps = extradata[i] & 0x1F; i += 1;
-    for _ in 0..num_sps {
-        if i + 2 > extradata.len() { return out; }
-        let n = ((extradata[i] as usize) << 8) | extradata[i + 1] as usize; i += 2;
-        out.extend_from_slice(&[0, 0, 0, 1]);
-        out.extend_from_slice(&extradata[i..i + n]); i += n;
-    }
-    if i >= extradata.len() { return out; }
-    let num_pps = extradata[i]; i += 1;
-    for _ in 0..num_pps {
-        if i + 2 > extradata.len() { return out; }
-        let n = ((extradata[i] as usize) << 8) | extradata[i + 1] as usize; i += 2;
-        out.extend_from_slice(&[0, 0, 0, 1]);
-        out.extend_from_slice(&extradata[i..i + n]); i += n;
-    }
-    out
-}
-
-fn avcc_to_annexb(packet: &[u8], out: &mut Vec<u8>) {
-    // 4-byte length-prefixed NALs → start-code-prefixed.
-    let mut i = 0usize;
-    while i + 4 <= packet.len() {
-        let n = ((packet[i] as usize) << 24) | ((packet[i + 1] as usize) << 16) | ((packet[i + 2] as usize) << 8) | packet[i + 3] as usize;
-        i += 4;
-        if i + n > packet.len() { break; }
-        out.extend_from_slice(&[0, 0, 0, 1]);
-        out.extend_from_slice(&packet[i..i + n]);
-        i += n;
-    }
-}
-
-fn main() {
-    ff::init().unwrap();
-    tracing_subscriber::fmt().with_env_filter("gpu_video=debug,warn").with_writer(std::io::stderr).init();
-
-    // gpu-video creates the Vulkan device (with video decode extensions) and the
-    // wgpu device on top.
-    let instance = gpu_video::VulkanInstance::new().expect("vulkan instance");
-    // decode only: this AMD iGPU exposes Vulkan Video DECODE but not encode (ffmpeg
-    // h264_vulkan failed with "Function not implemented"). The default descriptor
-    // demands both and returns NoDevice; ask for decode alone.
-    let adapter = instance.create_adapter(&gp::VulkanAdapterDescriptor {
-        supports_decoding: true,
-        supports_encoding: false,
-        compatible_surface: None,
-    }).expect("adapter");
-    let device = adapter.create_device(&gp::VulkanDeviceDescriptor::default()).expect("device");
-    let wdev = device.wgpu_device();
-    println!("gpu-video device up. wgpu adapter: {}", wdev.limits().max_texture_dimension_2d);
-
-    let mut decoder = device
-        .create_wgpu_textures_decoder_h264(gp::DecoderParameters::default())
-        .expect("h264 decoder");
-
-    // Demux screen.mp4 → Annex-B H.264, feed to the Vulkan decoder.
-    let mut ictx = ff::format::input(&"../poc/media/screen.mp4").unwrap();
-    let stream = ictx.streams().best(ff::media::Type::Video).unwrap();
-    let idx = stream.index();
-    let params = stream.parameters();
-    let extradata = unsafe {
-        let p = params.as_ptr();
-        let (ed, n) = ((*p).extradata, (*p).extradata_size as usize);
-        if ed.is_null() || n == 0 { Vec::new() } else { std::slice::from_raw_parts(ed, n).to_vec() }
-    };
-
-    let header = avcc_sps_pps(&extradata);
-    let mut decoded = 0usize;
-    let mut first_reported = false;
-    let mut annexb = Vec::new();
-
-    'outer: for (s, p) in ictx.packets() {
-        if s.index() != idx { continue; }
-        annexb.clear();
-        if !first_reported && !header.is_empty() { annexb.extend_from_slice(&header); }
-        avcc_to_annexb(p.data().unwrap_or(&[]), &mut annexb);
-
-        let frames = match decoder.decode(gpu_video::EncodedInputChunk { data: &annexb, pts: None }) {
-            Ok(f) => f,
-            Err(e) => { eprintln!("decode error: {e:?}"); break; }
-        };
-        for frame in frames {
-            let tex: &wgpu::Texture = &frame.data;
-            if !first_reported {
-                println!("ZERO-COPY DECODE OK: wgpu::Texture {}x{} format {:?}", tex.width(), tex.height(), tex.format());
-                first_reported = true;
-            }
-            decoded += 1;
-            if decoded >= 30 { break 'outer; }
-        }
-    }
-    println!("decoded {decoded} frames into wgpu textures, no CPU roundtrip");
-}
diff --git a/poc-native/src/composite.wgsl b/poc-native/src/composite.wgsl
deleted file mode 100644
index 129b028b6b..0000000000
--- a/poc-native/src/composite.wgsl
+++ /dev/null
@@ -1,177 +0,0 @@
-// Native compositor — the same WGSL as the web POC, adapted for native wgpu.
-//
-// Two changes only, both because `texture_external` is a WebGPU-only feature that
-// native wgpu does not have:
-//   texture_external            -> texture_2d<f32>
-//   textureSampleBaseClampToEdge -> textureSampleLevel(..., 0.0)
-// Everything else — the geometry, the erf Gaussian shadow, the cursor SDF — is
-// byte-for-byte the browser shader. That is the portability the whole bet rests
-// on: the product's substance moves to native unchanged.
-//
-// Single pass here (not the web POC's 6 culled quads): natively the compositor is
-// nowhere near the bottleneck, so the quad-culling buys nothing and the one
-// fragment shader is simpler.
-
-struct U {
-  // stage.xy | time | screenRadius
-  a : vec4f,
-  // screenRect x,y,w,h (carries zoom)
-  screen : vec4f,
-  // webcamRect x,y,w,h (carries layout animation)
-  webcam : vec4f,
-  // shadowIntensity | bgBlurPx(unused native) | shadowOffsetY | shadowSigma
-  fx : vec4f,
-  // webcamRadius | motionBlur baked elsewhere | webcamCoverScale | unused
-  b : vec4f,
-  // screenBlur.xy | webcamBlur.xy
-  mb : vec4f,
-  // cursor x | y | size | opacity
-  cursor : vec4f,
-  // cursorBlur.xy | clickScale | unused
-  cursorFx : vec4f,
-};
-
-@group(0) @binding(0) var<uniform> u : U;
-@group(0) @binding(1) var samp : sampler;
-@group(0) @binding(2) var screenTex : texture_2d<f32>;
-@group(0) @binding(3) var webcamTex : texture_2d<f32>;
-
-struct VsOut {
-  @builtin(position) pos : vec4f,
-  @location(0) uv : vec2f,
-};
-
-@vertex
-fn vs(@builtin(vertex_index) i : u32) -> VsOut {
-  var out : VsOut;
-  let x = f32((i << 1u) & 2u);
-  let y = f32(i & 2u);
-  out.uv = vec2f(x, y);
-  out.pos = vec4f(x * 2.0 - 1.0, 1.0 - y * 2.0, 0.0, 1.0);
-  return out;
-}
-
-fn sdRoundBox(p : vec2f, half : vec2f, r : f32) -> f32 {
-  let rr = min(r, min(half.x, half.y));
-  let q = abs(p) - half + vec2f(rr);
-  return length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0) - rr;
-}
-fn cover(d : f32) -> f32 { return clamp(0.5 - d, 0.0, 1.0); }
-fn over(dst : vec3f, src : vec3f, a : f32) -> vec3f { return mix(dst, src, clamp(a, 0.0, 1.0)); }
-
-// ---- background: computed gradient ----
-fn gradient(uv : vec2f) -> vec3f {
-  let a = vec3f(0.06, 0.11, 0.24);
-  let b = vec3f(0.35, 0.12, 0.42);
-  let c = vec3f(0.02, 0.35, 0.38);
-  let w = 0.5 + 0.5 * sin(uv.x * 2.0);
-  return mix(mix(a, b, uv.y), c, w * 0.45);
-}
-
-// ---- shadow: analytic Gaussian (erf), same as web ----
-const SQRT_2PI = 2.5066282746310002;
-const INV_SQRT_2 = 0.7071067811865476;
-fn gauss1(x : f32, sigma : f32) -> f32 { return exp(-(x * x) / (2.0 * sigma * sigma)) / (SQRT_2PI * sigma); }
-fn erf2(x : vec2f) -> vec2f {
-  let s = sign(x); let a = abs(x);
-  var r = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
-  r = r * r; return s - s / (r * r);
-}
-fn shadowRowX(x : f32, y : f32, sigma : f32, corner : f32, half : vec2f) -> f32 {
-  let d = min(half.y - corner - abs(y), 0.0);
-  let curved = half.x - corner + sqrt(max(0.0, corner * corner - d * d));
-  let integral = 0.5 + 0.5 * erf2((x + vec2f(-curved, curved)) * (INV_SQRT_2 / sigma));
-  return integral.y - integral.x;
-}
-fn shadowAt(px : vec2f, rect : vec4f, radius : f32, intensity : f32) -> f32 {
-  if (intensity <= 0.0) { return 0.0; }
-  let sigma = max(u.fx.w, 0.5);
-  let half = rect.zw * 0.5;
-  let corner = min(radius, min(half.x, half.y));
-  let p = px - (rect.xy + half + vec2f(0.0, u.fx.z));
-  let low = p.y - half.y; let high = p.y + half.y;
-  let start = clamp(-3.0 * sigma, low, high);
-  let end = clamp(3.0 * sigma, low, high);
-  let step = (end - start) / 4.0;
-  var y = start + step * 0.5; var value = 0.0;
-  for (var i = 0; i < 4; i = i + 1) {
-    value = value + shadowRowX(p.x, p.y - y, sigma, corner, half) * gauss1(y, sigma) * step;
-    y = y + step;
-  }
-  return clamp(value, 0.0, 1.0) * intensity;
-}
-
-// ---- sources ----
-fn sampleScreen(px : vec2f, blur : vec2f) -> vec3f {
-  let uv0 = (px - u.screen.xy) / max(u.screen.zw, vec2f(1.0));
-  if (length(blur) < 0.5) {
-    return textureSampleLevel(screenTex, samp, clamp(uv0, vec2f(0.0), vec2f(1.0)), 0.0).rgb;
-  }
-  var acc = vec3f(0.0); let taps = 7;
-  for (var i = 0; i < taps; i = i + 1) {
-    let t = (f32(i) / f32(taps - 1)) - 0.5;
-    let uv = ((px + blur * t) - u.screen.xy) / max(u.screen.zw, vec2f(1.0));
-    acc = acc + textureSampleLevel(screenTex, samp, clamp(uv, vec2f(0.0), vec2f(1.0)), 0.0).rgb;
-  }
-  return acc / f32(taps);
-}
-fn sampleWebcam(px : vec2f, centre : vec2f) -> vec3f {
-  var uv = (px - centre) / max(u.webcam.zw, vec2f(1.0));
-  uv = uv * vec2f(u.b.z, 1.0) + vec2f(0.5);
-  return textureSampleLevel(webcamTex, samp, clamp(uv, vec2f(0.0), vec2f(1.0)), 0.0).rgb;
-}
-
-// ---- cursor: arrow polygon SDF ----
-fn sdCursor(p : vec2f) -> f32 {
-  var v = array<vec2f, 7>(
-    vec2f(0.00, 0.00), vec2f(0.00, 1.00), vec2f(0.24, 0.76),
-    vec2f(0.40, 1.14), vec2f(0.56, 1.07), vec2f(0.39, 0.69), vec2f(0.70, 0.69),
-  );
-  var d = dot(p - v[0], p - v[0]); var s = 1.0;
-  for (var i = 0; i < 7; i = i + 1) {
-    let j = (i + 6) % 7;
-    let e = v[j] - v[i]; let w = p - v[i];
-    let b = w - e * clamp(dot(w, e) / dot(e, e), 0.0, 1.0);
-    d = min(d, dot(b, b));
-    let c0 = p.y >= v[i].y; let c1 = p.y < v[j].y; let c2 = e.x * w.y > e.y * w.x;
-    if ((c0 && c1 && c2) || (!c0 && !c1 && !c2)) { s = -s; }
-  }
-  return s * sqrt(d);
-}
-fn cursorFill(px : vec2f, shrink : f32) -> f32 {
-  let s = u.cursor.z / 1.2;
-  let local = (px - u.cursor.xy) / max(s, 1.0) / u.cursorFx.z;
-  return cover((sdCursor(local) * s * u.cursorFx.z) - shrink);
-}
-
-@fragment
-fn fs(in : VsOut) -> @location(0) vec4f {
-  let px = in.uv * u.a.xy;
-
-  // 1. background
-  var colour = gradient(in.uv);
-
-  // 2. screen shadow (analytic Gaussian)
-  colour = over(colour, vec3f(0.0), shadowAt(px, u.screen, u.a.w, u.fx.x));
-
-  // 3. screen (zoom + motion blur + rounded mask)
-  let sc = cover(sdRoundBox(px - (u.screen.xy + u.screen.zw * 0.5), u.screen.zw * 0.5, u.a.w));
-  if (sc > 0.0) { colour = over(colour, sampleScreen(px, u.mb.xy), sc); }
-
-  // 4. webcam shadow + webcam (shape morphs via radius)
-  colour = over(colour, vec3f(0.0), shadowAt(px, u.webcam, u.b.x, u.fx.x * 0.8));
-  let centre = u.webcam.xy + u.webcam.zw * 0.5;
-  let wc = cover(sdRoundBox(px - centre, u.webcam.zw * 0.5, u.b.x));
-  if (wc > 0.0) { colour = over(colour, sampleWebcam(px, centre), wc); }
-
-  // 5. cursor: white fill + black rim, motion-blurred, click-bounced
-  let outline = max(u.cursor.z * 0.05, 1.5);
-  let fill = cursorFill(px, 0.0);
-  let edge = cursorFill(px, outline);
-  if (edge > 0.001) {
-    let rgb = vec3f(fill / max(edge, 1e-4));
-    colour = over(colour, rgb, edge * u.cursor.w);
-  }
-
-  return vec4f(colour, 1.0);
-}
diff --git a/poc-native/src/main.rs b/poc-native/src/main.rs
deleted file mode 100644
index 04979ba6a8..0000000000
--- a/poc-native/src/main.rs
+++ /dev/null
@@ -1,295 +0,0 @@
-// Native full-shader compositor POC — milestone 1: prove wgpu runs the WGSL and
-// composites a real frame, natively, no browser.
-//
-// Decode one real frame from each source with ffmpeg (to raw RGBA), upload as
-// wgpu textures, run the SAME shader as the web POC (adapted for native), render
-// to an offscreen 1080p target, read it back, write a BMP. If the picture matches
-// the web POC at the same t, the compositor has moved to native unchanged.
-
-use std::fs;
-use std::process::Command;
-
-const OUT_W: u32 = 1920;
-const OUT_H: u32 = 1080;
-const SCREEN_W: u32 = 1920;
-const SCREEN_H: u32 = 1032;
-const WEBCAM_W: u32 = 640;
-const WEBCAM_H: u32 = 480;
-
-#[repr(C)]
-#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
-struct Uniforms {
-    a: [f32; 4],
-    screen: [f32; 4],
-    webcam: [f32; 4],
-    fx: [f32; 4],
-    b: [f32; 4],
-    mb: [f32; 4],
-    cursor: [f32; 4],
-    cursor_fx: [f32; 4],
-}
-
-struct Rect {
-    x: f32,
-    y: f32,
-    w: f32,
-    h: f32,
-}
-
-// evaluate(), ported from the web POC. At t=0.5s: no zoom (starts 1.0), no layout
-// move (starts 2.4), so the recording sits padded and the webcam is a docked
-// circle — the frame where background + shadow + rounded corners are all visible.
-fn base_layout(padding: f32) -> (Rect, Rect) {
-    let s = 1.0 - (padding / 100.0) * 0.4;
-    let w = OUT_W as f32 * s;
-    let h = OUT_H as f32 * s;
-    let screen = Rect {
-        x: (OUT_W as f32 - w) / 2.0,
-        y: (OUT_H as f32 - h) / 2.0,
-        w,
-        h,
-    };
-    let size = (OUT_H as f32 * 0.22).round();
-    let margin = (OUT_H as f32 * 0.04).round();
-    let webcam = Rect {
-        x: OUT_W as f32 - size - margin,
-        y: OUT_H as f32 - size - margin,
-        w: size,
-        h: size,
-    };
-    (screen, webcam)
-}
-
-fn decode_frame(path: &str, t: &str, w: u32, h: u32, out: &str) -> Vec<u8> {
-    // One real frame → raw RGBA. ffmpeg is the native hardware/software decoder;
-    // this is the decode seam. For the compositor milestone it runs once.
-    let status = Command::new("ffmpeg")
-        .args([
-            "-hide_banner", "-loglevel", "error", "-y", "-ss", t, "-i", path, "-frames:v", "1",
-            "-f", "rawvideo", "-pix_fmt", "rgba", out,
-        ])
-        .status()
-        .expect("ffmpeg failed to run");
-    assert!(status.success(), "ffmpeg decode failed for {path}");
-    let data = fs::read(out).expect("read decoded frame");
-    assert_eq!(data.len(), (w * h * 4) as usize, "unexpected frame size for {path}");
-    data
-}
-
-fn make_texture(
-    device: &wgpu::Device,
-    queue: &wgpu::Queue,
-    w: u32,
-    h: u32,
-    rgba: &[u8],
-    label: &str,
-) -> wgpu::TextureView {
-    let tex = device.create_texture(&wgpu::TextureDescriptor {
-        label: Some(label),
-        size: wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
-        mip_level_count: 1,
-        sample_count: 1,
-        dimension: wgpu::TextureDimension::D2,
-        format: wgpu::TextureFormat::Rgba8Unorm,
-        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-        view_formats: &[],
-    });
-    queue.write_texture(
-        wgpu::ImageCopyTexture {
-            texture: &tex,
-            mip_level: 0,
-            origin: wgpu::Origin3d::ZERO,
-            aspect: wgpu::TextureAspect::All,
-        },
-        rgba,
-        wgpu::ImageDataLayout {
-            offset: 0,
-            bytes_per_row: Some(w * 4),
-            rows_per_image: Some(h),
-        },
-        wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
-    );
-    tex.create_view(&wgpu::TextureViewDescriptor::default())
-}
-
-fn write_bmp(path: &str, w: u32, h: u32, rgba: &[u8]) {
-    // 24-bit BMP, bottom-up. No image crate: keeps the native POC's deps to wgpu.
-    let row = (w * 3 + 3) & !3; // 4-byte aligned
-    let size = 54 + row * h;
-    let mut f = Vec::with_capacity(size as usize);
-    f.extend_from_slice(b"BM");
-    f.extend_from_slice(&size.to_le_bytes());
-    f.extend_from_slice(&0u32.to_le_bytes());
-    f.extend_from_slice(&54u32.to_le_bytes());
-    f.extend_from_slice(&40u32.to_le_bytes());
-    f.extend_from_slice(&(w as i32).to_le_bytes());
-    f.extend_from_slice(&(h as i32).to_le_bytes());
-    f.extend_from_slice(&1u16.to_le_bytes());
-    f.extend_from_slice(&24u16.to_le_bytes());
-    f.extend_from_slice(&[0u8; 24]);
-    for y in (0..h).rev() {
-        let mut written = 0u32;
-        for x in 0..w {
-            let i = ((y * w + x) * 4) as usize;
-            f.push(rgba[i + 2]);
-            f.push(rgba[i + 1]);
-            f.push(rgba[i]);
-            written += 3;
-        }
-        while written < row {
-            f.push(0);
-            written += 1;
-        }
-    }
-    fs::write(path, f).expect("write bmp");
-}
-
-fn main() {
-    let t = 0.5f32;
-    let padding = 45.0f32;
-
-    // --- decode one real frame from each source ---
-    let screen_rgba = decode_frame("../poc/media/screen.mp4", "0.5", SCREEN_W, SCREEN_H, "screen.rgba");
-    let webcam_rgba = decode_frame("../poc/media/webcam.mp4", "0.5", WEBCAM_W, WEBCAM_H, "webcam.rgba");
-
-    // --- wgpu init (native: Vulkan/D3D12/Metal under the hood) ---
-    let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::default());
-    let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
-        power_preference: wgpu::PowerPreference::HighPerformance,
-        ..Default::default()
-    }))
-    .expect("no GPU adapter");
-    let info = adapter.get_info();
-    println!("native gpu: {} ({:?}, backend {:?})", info.name, info.device_type, info.backend);
-    let (device, queue) = pollster::block_on(adapter.request_device(
-        &wgpu::DeviceDescriptor { label: None, required_features: wgpu::Features::empty(), required_limits: wgpu::Limits::default(), memory_hints: wgpu::MemoryHints::Performance },
-        None,
-    ))
-    .expect("no device");
-
-    let screen_view = make_texture(&device, &queue, SCREEN_W, SCREEN_H, &screen_rgba, "screen");
-    let webcam_view = make_texture(&device, &queue, WEBCAM_W, WEBCAM_H, &webcam_rgba, "webcam");
-    let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
-        mag_filter: wgpu::FilterMode::Linear,
-        min_filter: wgpu::FilterMode::Linear,
-        ..Default::default()
-    });
-
-    // --- uniforms: evaluate() at t=0.5 ---
-    let (screen, webcam) = base_layout(padding);
-    let cam_aspect = WEBCAM_W as f32 / WEBCAM_H as f32;
-    let cur_x = screen.x + 0.52 * screen.w;
-    let cur_y = screen.y + 0.90 * screen.h;
-    let cur_size = OUT_H as f32 * 0.05;
-    let uniforms = Uniforms {
-        a: [OUT_W as f32, OUT_H as f32, t, 28.0],
-        screen: [screen.x, screen.y, screen.w, screen.h],
-        webcam: [webcam.x, webcam.y, webcam.w, webcam.h],
-        fx: [0.7, 0.0, 16.0, 22.0],
-        b: [webcam.w.min(webcam.h) / 2.0, 0.0, cam_aspect, 0.0],
-        mb: [0.0, 0.0, 0.0, 0.0],
-        cursor: [cur_x, cur_y, cur_size, 1.0],
-        cursor_fx: [0.0, 0.0, 1.0, 0.0],
-    };
-    let ubuf = device.create_buffer(&wgpu::BufferDescriptor {
-        label: Some("uniforms"),
-        size: std::mem::size_of::<Uniforms>() as u64,
-        usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-        mapped_at_creation: false,
-    });
-    queue.write_buffer(&ubuf, 0, bytemuck::bytes_of(&uniforms));
-
-    // --- pipeline ---
-    let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-        label: Some("composite"),
-        source: wgpu::ShaderSource::Wgsl(include_str!("composite.wgsl").into()),
-    });
-    let format = wgpu::TextureFormat::Rgba8Unorm;
-    let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-        label: Some("composite"),
-        layout: None,
-        vertex: wgpu::VertexState { module: &shader, entry_point: "vs", buffers: &[], compilation_options: Default::default() },
-        fragment: Some(wgpu::FragmentState {
-            module: &shader,
-            entry_point: "fs",
-            targets: &[Some(wgpu::ColorTargetState { format, blend: None, write_mask: wgpu::ColorWrites::ALL })],
-            compilation_options: Default::default(),
-        }),
-        primitive: wgpu::PrimitiveState::default(),
-        depth_stencil: None,
-        multisample: wgpu::MultisampleState::default(),
-        multiview: None,
-        cache: None,
-    });
-
-    let target = device.create_texture(&wgpu::TextureDescriptor {
-        label: Some("target"),
-        size: wgpu::Extent3d { width: OUT_W, height: OUT_H, depth_or_array_layers: 1 },
-        mip_level_count: 1,
-        sample_count: 1,
-        dimension: wgpu::TextureDimension::D2,
-        format,
-        usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
-        view_formats: &[],
-    });
-    let target_view = target.create_view(&wgpu::TextureViewDescriptor::default());
-
-    let bind = device.create_bind_group(&wgpu::BindGroupDescriptor {
-        label: None,
-        layout: &pipeline.get_bind_group_layout(0),
-        entries: &[
-            wgpu::BindGroupEntry { binding: 0, resource: ubuf.as_entire_binding() },
-            wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&sampler) },
-            wgpu::BindGroupEntry { binding: 2, resource: wgpu::BindingResource::TextureView(&screen_view) },
-            wgpu::BindGroupEntry { binding: 3, resource: wgpu::BindingResource::TextureView(&webcam_view) },
-        ],
-    });
-
-    // --- render ---
-    let mut enc = device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
-    {
-        let mut pass = enc.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: None,
-            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                view: &target_view,
-                resolve_target: None,
-                ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color::BLACK), store: wgpu::StoreOp::Store },
-            })],
-            depth_stencil_attachment: None,
-            timestamp_writes: None,
-            occlusion_query_set: None,
-        });
-        pass.set_pipeline(&pipeline);
-        pass.set_bind_group(0, &bind, &[]);
-        pass.draw(0..3, 0..1);
-    }
-
-    // --- readback → BMP ---
-    let bpr = ((OUT_W * 4 + 255) & !255) as u64; // 256-aligned
-    let rbuf = device.create_buffer(&wgpu::BufferDescriptor {
-        label: Some("readback"),
-        size: bpr * OUT_H as u64,
-        usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
-        mapped_at_creation: false,
-    });
-    enc.copy_texture_to_buffer(
-        wgpu::ImageCopyTexture { texture: &target, mip_level: 0, origin: wgpu::Origin3d::ZERO, aspect: wgpu::TextureAspect::All },
-        wgpu::ImageCopyBuffer { buffer: &rbuf, layout: wgpu::ImageDataLayout { offset: 0, bytes_per_row: Some(bpr as u32), rows_per_image: Some(OUT_H) } },
-        wgpu::Extent3d { width: OUT_W, height: OUT_H, depth_or_array_layers: 1 },
-    );
-    queue.submit([enc.finish()]);
-
-    let slice = rbuf.slice(..);
-    slice.map_async(wgpu::MapMode::Read, |r| r.unwrap());
-    device.poll(wgpu::Maintain::Wait);
-    let mapped = slice.get_mapped_range();
-    // Un-pad the 256-aligned rows into tight RGBA.
-    let mut tight = vec![0u8; (OUT_W * OUT_H * 4) as usize];
-    for y in 0..OUT_H {
-        let src = (y as u64 * bpr) as usize;
-        let dst = (y * OUT_W * 4) as usize;
-        tight[dst..dst + (OUT_W * 4) as usize].copy_from_slice(&mapped[src..src + (OUT_W * 4) as usize]);
-    }
-    write_bmp("out.bmp", OUT_W, OUT_H, &tight);
-    println!("wrote out.bmp — composited natively at t={t}s");
-}
diff --git a/poc/composite.wgsl b/poc/composite.wgsl
deleted file mode 100644
index 72b11af1d7..0000000000
--- a/poc/composite.wgsl
+++ /dev/null
@@ -1,378 +0,0 @@
-// The compositor. Two sources, one layout, three effects — written from zero.
-//
-// Drawn the way a game draws: one quad per element, sized to the element. The
-// rasterizer then runs the fragment shader ONLY on the pixels that element
-// covers, and clips whatever falls outside the frame — for free, in fixed
-// function, with no branch. A zoomed recording is 2.7x the stage: two thirds of
-// it is off-screen and costs nothing.
-//
-// The alternative — one fullscreen triangle with `if`s — pays for every pixel of
-// every effect and then throws most of it away. That is what the first version of
-// this file did.
-//
-// Everything is a pure function of the uniforms. No cache: a shader recomputes
-// every pixel every frame, which is the point of the paradigm.
-
-struct U {
-  // stage.xy | unused | screenRadius
-  a : vec4f,
-  // screenRect: x, y, w, h — already carries the zoom (scale + pan)
-  screen : vec4f,
-  // webcamRect: x, y, w, h — already carries the layout animation
-  webcam : vec4f,
-  // shadowIntensity | bgBlurPx | shadowOffsetY | shadowSpread
-  fx : vec4f,
-  // webcamRadius | unused | webcamCoverScale | optimised(0/1)
-  b : vec4f,
-  // Directional motion blur, in pixels: screenBlur.xy | webcamBlur.xy. A vector,
-  // not a scalar — the recording smears along the camera's real travel, which
-  // during a pan or a layout move is not horizontal.
-  mb : vec4f,
-  // The cursor, drawn synthetically from the recorded trace: x | y | size |
-  // opacity. Position is in stage pixels, already carried through the zoom.
-  cursor : vec4f,
-  // cursorBlur.xy | clickScale | unused. clickScale pulses on a real click.
-  cursorFx : vec4f,
-};
-
-@group(0) @binding(0) var<uniform> u : U;
-@group(0) @binding(1) var samp : sampler;
-@group(0) @binding(2) var screenTex : texture_external;
-@group(0) @binding(3) var webcamTex : texture_external;
-@group(0) @binding(4) var bgTex : texture_2d<f32>;
-
-struct VsOut {
-  @builtin(position) pos : vec4f,
-  // Stage-space uv (0..1 across the OUTPUT), not the quad's own uv: the fragment
-  // shaders all reason in stage pixels, and the quad is only there to bound them.
-  @location(0) uv : vec2f,
-};
-
-// ---- vertex: one quad per element ------------------------------------------
-
-/**
- * Emit `rect` as two triangles in stage space.
- *
- * Clipping is the rasterizer's job: a rect that runs off the stage — every zoomed
- * recording — is cut by fixed-function hardware before a single fragment is
- * dispatched.
- */
-fn quad(vi : u32, rect : vec4f) -> VsOut {
-  var corners = array<vec2f, 6>(
-    vec2f(0.0, 0.0), vec2f(1.0, 0.0), vec2f(0.0, 1.0),
-    vec2f(0.0, 1.0), vec2f(1.0, 0.0), vec2f(1.0, 1.0),
-  );
-  let c = corners[vi];
-  let px = rect.xy + c * rect.zw;
-  var out : VsOut;
-  out.pos = vec4f(px.x / u.a.x * 2.0 - 1.0, 1.0 - px.y / u.a.y * 2.0, 0.0, 1.0);
-  out.uv = px / u.a.xy;
-  return out;
-}
-
-@vertex fn vsFull(@builtin(vertex_index) i : u32) -> VsOut {
-  return quad(i, vec4f(0.0, 0.0, u.a.x, u.a.y));
-}
-
-@vertex fn vsScreen(@builtin(vertex_index) i : u32) -> VsOut {
-  return quad(i, u.screen);
-}
-
-/** The shadow's quad: the rect grown by 3σ, the Gaussian's reach. */
-@vertex fn vsScreenShadow(@builtin(vertex_index) i : u32) -> VsOut {
-  let s = u.fx.w * 3.0 + 1.0;
-  return quad(i, vec4f(u.screen.xy - vec2f(s), u.screen.zw + vec2f(s * 2.0)) + vec4f(0.0, u.fx.z, 0.0, 0.0));
-}
-
-@vertex fn vsWebcam(@builtin(vertex_index) i : u32) -> VsOut {
-  return quad(i, u.webcam);
-}
-
-@vertex fn vsWebcamShadow(@builtin(vertex_index) i : u32) -> VsOut {
-  let s = u.fx.w * 3.0 + 1.0;
-  return quad(i, vec4f(u.webcam.xy - vec2f(s), u.webcam.zw + vec2f(s * 2.0)) + vec4f(0.0, u.fx.z, 0.0, 0.0));
-}
-
-/** The cursor's quad: its box, grown for the shadow, the click bounce and the smear. */
-@vertex fn vsCursor(@builtin(vertex_index) i : u32) -> VsOut {
-  let size = u.cursor.z;
-  let pad = 6.0 + length(u.cursorFx.xy);
-  let rect = vec4f(u.cursor.xy - vec2f(pad), vec2f(size * 1.5 + pad * 2.0));
-  return quad(i, rect);
-}
-
-// ---- geometry ---------------------------------------------------------------
-
-/** Signed distance to a rounded box. Negative inside. */
-fn sdRoundBox(p : vec2f, half : vec2f, r : f32) -> f32 {
-  let rr = min(r, min(half.x, half.y));
-  let q = abs(p) - half + vec2f(rr);
-  return length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0) - rr;
-}
-
-/** Antialiased coverage from a signed distance: one pixel of ramp. */
-fn cover(d : f32) -> f32 {
-  return clamp(0.5 - d, 0.0, 1.0);
-}
-
-// ---- effect 1: the background ----------------------------------------------
-//
-// A blurred gradient, baked into a texture ONCE by fsBake. The frame reads one
-// texel — and only where the recording does not already cover it.
-//
-// It was 16 gradient evaluations per pixel per frame, every one recomputing a
-// CONSTANT. This is not the shadow cache in disguise, and the difference is the
-// whole argument: a cache guesses that its input has not changed and needs a key
-// to find out. This has no key because it has no input — the background IS a
-// constant. The shadow follows the camera, so it gets no such luxury.
-
-fn gradient(uv : vec2f) -> vec3f {
-  let a = vec3f(0.06, 0.11, 0.24);
-  let b = vec3f(0.35, 0.12, 0.42);
-  let c = vec3f(0.02, 0.35, 0.38);
-  let w = 0.5 + 0.5 * sin(uv.x * 2.0);
-  return mix(mix(a, b, uv.y), c, w * 0.45);
-}
-
-fn blurredGradient(uv : vec2f) -> vec3f {
-  let radiusPx = u.fx.y;
-  if (radiusPx < 0.5) {
-    return gradient(uv);
-  }
-  let px = radiusPx / u.a.xy;
-  var acc = vec3f(0.0);
-  let taps = 16;
-  let golden = 2.39996;
-  for (var i = 0; i < taps; i = i + 1) {
-    let fi = f32(i);
-    let r = sqrt((fi + 0.5) / f32(taps));
-    let a = fi * golden;
-    acc = acc + gradient(uv + vec2f(cos(a), sin(a)) * r * px);
-  }
-  return acc / f32(taps);
-}
-
-/** Init only. */
-@fragment fn fsBake(in : VsOut) -> @location(0) vec4f {
-  return vec4f(blurredGradient(in.uv), 1.0);
-}
-
-/** Per frame: one texel — or the naive 16 taps, for the A/B. */
-@fragment fn fsBackground(in : VsOut) -> @location(0) vec4f {
-  if (u.b.w > 0.5) {
-    return vec4f(textureSampleLevel(bgTex, samp, in.uv, 0.0).rgb, 1.0);
-  }
-  return vec4f(blurredGradient(in.uv), 1.0);
-}
-
-// ---- effect 2: the drop shadow ----------------------------------------------
-//
-// A REAL Gaussian, computed analytically — not sampled.
-//
-// The wrong way (what this replaced): sample the rounded-box SDF at a ring of
-// offsets and average. Few taps band into visible rings, many taps are slow, and
-// neither is a Gaussian — it is a box blur of a hard mask. It looked like stacked
-// translucent rectangles because that is exactly what it was.
-//
-// The right way (Evan Wallace, "Fast Rounded Rectangle Shadows"): the convolution
-// of a 2D Gaussian with a box is separable and each axis is an integral of the
-// Gaussian — which is the error function, erf. So a plain box shadow is a closed
-// form, no samples at all: `(erf(right) - erf(left)) * (erf(top) - erf(bottom))`.
-// Rounded corners break separability only near the corner, so the x extent is
-// integrated against the Gaussian in y over a handful of steps — the exact
-// profile, smoothly weighted, no banding. O(1) per pixel and beautiful.
-
-const SQRT_2PI = 2.5066282746310002;
-const INV_SQRT_2 = 0.7071067811865476;
-
-fn gauss1(x : f32, sigma : f32) -> f32 {
-  return exp(-(x * x) / (2.0 * sigma * sigma)) / (SQRT_2PI * sigma);
-}
-
-/** erf, componentwise (Abramowitz & Stegun 7.1.27). Max error ~5e-4. */
-fn erf2(x : vec2f) -> vec2f {
-  let s = sign(x);
-  let a = abs(x);
-  var r = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
-  r = r * r;
-  return s - s / (r * r);
-}
-
-/** Fraction of a Gaussian-blurred box covering x, at height y, with rounded corners. */
-fn shadowRowX(x : f32, y : f32, sigma : f32, corner : f32, half : vec2f) -> f32 {
-  // How far the rounded corner pulls the edge in at this height.
-  let d = min(half.y - corner - abs(y), 0.0);
-  let curved = half.x - corner + sqrt(max(0.0, corner * corner - d * d));
-  let integral = 0.5 + 0.5 * erf2((x + vec2f(-curved, curved)) * (INV_SQRT_2 / sigma));
-  return integral.y - integral.x;
-}
-
-fn shadowAt(px : vec2f, rect : vec4f, radius : f32, intensity : f32) -> f32 {
-  if (intensity <= 0.0) {
-    return 0.0;
-  }
-  let sigma = max(u.fx.w, 0.5);
-  let half = rect.zw * 0.5;
-  let corner = min(radius, min(half.x, half.y));
-  // Offset the shadow down by u.fx.z, like a light from above.
-  let p = px - (rect.xy + half + vec2f(0.0, u.fx.z));
-
-  // Integrate the x-profile against the Gaussian in y, over ±3σ clamped to the
-  // box — four steps is plenty because each is analytic in x.
-  let low = p.y - half.y;
-  let high = p.y + half.y;
-  let start = clamp(-3.0 * sigma, low, high);
-  let end = clamp(3.0 * sigma, low, high);
-  let step = (end - start) / 4.0;
-  var y = start + step * 0.5;
-  var value = 0.0;
-  for (var i = 0; i < 4; i = i + 1) {
-    value = value + shadowRowX(p.x, p.y - y, sigma, corner, half) * gauss1(y, sigma) * step;
-    y = y + step;
-  }
-  return clamp(value, 0.0, 1.0) * intensity;
-}
-
-@fragment fn fsScreenShadow(in : VsOut) -> @location(0) vec4f {
-  return vec4f(0.0, 0.0, 0.0, shadowAt(in.uv * u.a.xy, u.screen, u.a.w, u.fx.x));
-}
-
-@fragment fn fsWebcamShadow(in : VsOut) -> @location(0) vec4f {
-  return vec4f(0.0, 0.0, 0.0, shadowAt(in.uv * u.a.xy, u.webcam, u.b.x, u.fx.x * 0.8));
-}
-
-// ---- effect 3: the masks + the sources --------------------------------------
-
-/**
- * The recording, smeared along the camera's travel while it moves.
- *
- * The blur is a VECTOR now (u.mb.xy): a pan or a layout move sends the camera
- * diagonally, and a horizontal-only smear would be wrong for exactly the motion a
- * screen demo has most of. Skipped at rest — a branch is free next to seven
- * fetches, and it is uniform across the frame.
- */
-fn sampleScreen(px : vec2f, blur : vec2f) -> vec3f {
-  let uv0 = (px - u.screen.xy) / max(u.screen.zw, vec2f(1.0));
-  if (length(blur) < 0.5) {
-    return textureSampleBaseClampToEdge(screenTex, samp, clamp(uv0, vec2f(0.0), vec2f(1.0))).rgb;
-  }
-  var acc = vec3f(0.0);
-  let taps = 7;
-  for (var i = 0; i < taps; i = i + 1) {
-    let t = (f32(i) / f32(taps - 1)) - 0.5;
-    let uv = ((px + blur * t) - u.screen.xy) / max(u.screen.zw, vec2f(1.0));
-    acc = acc + textureSampleBaseClampToEdge(screenTex, samp, clamp(uv, vec2f(0.0), vec2f(1.0))).rgb;
-  }
-  return acc / f32(taps);
-}
-
-@fragment fn fsScreen(in : VsOut) -> @location(0) vec4f {
-  let px = in.uv * u.a.xy;
-  let c = cover(sdRoundBox(px - (u.screen.xy + u.screen.zw * 0.5), u.screen.zw * 0.5, u.a.w));
-  if (c <= 0.0) {
-    discard;
-  }
-  return vec4f(sampleScreen(px, u.mb.xy), c);
-}
-
-// ---- the cursor -------------------------------------------------------------
-//
-// Drawn from the recorded trace, per frame — never baked into the video. A
-// polygon SDF, so it is a shape the shader computes, not a sprite it samples; the
-// real app swaps theme PNGs in here, which is a texture read in the same quad,
-// not a different pipeline. The hard parts a POC has to prove are all here: it
-// follows the zoom (its position rides the screen rect), it bounces on a real
-// click (clickScale), it casts a shadow, and it smears when it moves fast.
-
-/** Signed distance to the classic arrow pointer, tip at local (0,0). Neg inside. */
-fn sdCursor(p : vec2f) -> f32 {
-  var v = array<vec2f, 7>(
-    vec2f(0.00, 0.00), vec2f(0.00, 1.00), vec2f(0.24, 0.76),
-    vec2f(0.40, 1.14), vec2f(0.56, 1.07), vec2f(0.39, 0.69), vec2f(0.70, 0.69),
-  );
-  var d = dot(p - v[0], p - v[0]);
-  var s = 1.0;
-  for (var i = 0; i < 7; i = i + 1) {
-    let j = (i + 6) % 7;
-    let e = v[j] - v[i];
-    let w = p - v[i];
-    let b = w - e * clamp(dot(w, e) / dot(e, e), 0.0, 1.0);
-    d = min(d, dot(b, b));
-    // Winding test. The three conditions are kept as scalars, not packed into a
-    // vec3<bool>: the `>` inside that constructor is parsed as a template close.
-    let c0 = p.y >= v[i].y;
-    let c1 = p.y < v[j].y;
-    let c2 = e.x * w.y > e.y * w.x;
-    if ((c0 && c1 && c2) || (!c0 && !c1 && !c2)) { s = -s; }
-  }
-  return s * sqrt(d);
-}
-
-/** Signed distance to the arrow at a stage pixel, in px, with the click bounce. */
-fn cursorSD(px : vec2f) -> f32 {
-  // Scale about the tip (local origin) so a click bounce pulls toward the
-  // hotspot, not the centre. 1.2 fits the 0..1.14 arrow inside the quad.
-  let s = u.cursor.z / 1.2;
-  let local = (px - u.cursor.xy) / max(s, 1.0) / u.cursorFx.z;
-  return sdCursor(local) * s * u.cursorFx.z;
-}
-
-@fragment fn fsCursor(in : VsOut) -> @location(0) vec4f {
-  let px = in.uv * u.a.xy;
-  let blur = u.cursorFx.xy;
-  let outline = max(u.cursor.z * 0.05, 1.5); // the arrow's own black rim, in px
-
-  // Fill (white interior) and outline (interior + rim) coverage, both smeared
-  // along the travel when the cursor moves fast. No drop shadow — the contrast on
-  // a light page is the rim, which is part of the pointer, not a cast shadow.
-  var fill = 0.0;
-  var edge = 0.0;
-  let moving = length(blur) >= 0.5;
-  let taps = select(1, 5, moving);
-  for (var i = 0; i < taps; i = i + 1) {
-    let t = select(0.0, (f32(i) / f32(taps - 1)) - 0.5, moving);
-    let d = cursorSD(px + blur * t);
-    fill = fill + cover(d);
-    edge = edge + cover(d - outline);
-  }
-  fill = fill / f32(taps);
-  edge = edge / f32(taps);
-
-  // White inside, fading to a black rim; `edge` carries the opacity so the rim is
-  // solid. The click bounce is already baked into cursorSD.
-  let rgb = vec3f(fill / max(edge, 1e-4));
-  return vec4f(rgb, edge * u.cursor.w);
-}
-
-/**
- * The webcam's mask, morphing with the layout animation: radius drives the shape,
- * circle when docked and rounded rect when grown. The SDF interpolates the SHAPE
- * for free — a tessellated 2D mask would rebuild geometry every frame for this.
- */
-fn sampleWebcam(px : vec2f, centre : vec2f) -> vec3f {
-  var uv = (px - centre) / max(u.webcam.zw, vec2f(1.0));
-  // Cover-fit: a 4:3 source in a square hole would squash without this.
-  uv = uv * vec2f(u.b.z, 1.0) + vec2f(0.5);
-  return textureSampleBaseClampToEdge(webcamTex, samp, clamp(uv, vec2f(0.0), vec2f(1.0))).rgb;
-}
-
-@fragment fn fsWebcam(in : VsOut) -> @location(0) vec4f {
-  let px = in.uv * u.a.xy;
-  let centre = u.webcam.xy + u.webcam.zw * 0.5;
-  let c = cover(sdRoundBox(px - centre, u.webcam.zw * 0.5, u.b.x));
-  if (c <= 0.0) {
-    discard;
-  }
-  // Smear along its travel during a layout move, exactly like the recording.
-  let blur = u.mb.zw;
-  if (length(blur) < 0.5) {
-    return vec4f(sampleWebcam(px, centre), c);
-  }
-  var acc = vec3f(0.0);
-  let taps = 5;
-  for (var i = 0; i < taps; i = i + 1) {
-    let t = (f32(i) / f32(taps - 1)) - 0.5;
-    acc = acc + sampleWebcam(px + blur * t, centre);
-  }
-  return vec4f(acc / f32(taps), c);
-}
diff --git a/poc/index.html b/poc/index.html
deleted file mode 100644
index a72fe2ccf5..0000000000
--- a/poc/index.html
+++ /dev/null
@@ -1,88 +0,0 @@
-<!doctype html>
-<html lang="fr">
-	<head>
-		<meta charset="utf-8" />
-		<title>POC full-shader — 2 sources, 1 layout, 3 effets</title>
-		<style>
-			body {
-				font-family: ui-sans-serif, system-ui, sans-serif;
-				background: #14141a;
-				color: #e8e8ee;
-				margin: 0;
-				padding: 24px;
-			}
-			h1 { font-size: 17px; font-weight: 500; margin: 0 0 4px; }
-			.sub { color: #8b8b9a; font-size: 13px; margin: 0 0 20px; }
-			.row { display: flex; gap: 20px; align-items: flex-end; flex-wrap: wrap; margin-bottom: 20px; }
-			label { font-size: 12px; color: #8b8b9a; display: block; margin-bottom: 4px; }
-			input { width: 70px; background: #22222c; color: #e8e8ee; border: 1px solid #33333f; border-radius: 6px; padding: 6px 8px; font-size: 13px; }
-			button { background: #3d7dff; color: #fff; border: 0; border-radius: 6px; padding: 9px 18px; font-size: 13px; font-weight: 500; cursor: pointer; }
-			button:disabled { background: #33333f; color: #6a6a78; cursor: default; }
-			.stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(120px, 1fr)); gap: 10px; margin-bottom: 18px; }
-			.stat { background: #1c1c24; border-radius: 8px; padding: 12px 14px; }
-			.stat .k { font-size: 11px; color: #8b8b9a; text-transform: uppercase; letter-spacing: 0.04em; }
-			.stat .v { font-size: 22px; font-weight: 500; margin-top: 3px; }
-			.hero .v { color: #4ade80; font-size: 32px; }
-			pre { background: #1c1c24; border-radius: 8px; padding: 14px; font-size: 12px; line-height: 1.55; min-height: 90px; overflow-x: auto; margin: 0 0 18px; }
-			video, canvas { width: 100%; max-width: 860px; border-radius: 8px; display: block; background: #000; }
-			canvas { margin-bottom: 14px; }
-			a { color: #3d7dff; font-size: 13px; }
-		</style>
-	</head>
-	<body>
-		<h1>POC full-shader — 2 sources, 1 layout, 3 effets</h1>
-		<p class="sub">
-			écran + webcam → un programme WGSL (flou, ombre, masque) → mp4. Aucun Electron, aucun
-			code de l'app.
-		</p>
-
-		<div class="row">
-			<div><label for="seconds">secondes</label><input id="seconds" type="number" value="4" min="1" max="30" /></div>
-			<div><label for="padding">padding</label><input id="padding" type="number" value="45" min="0" max="90" /></div>
-			<div><label for="shadow">ombre</label><input id="shadow" type="number" value="0.65" min="0" max="1" step="0.05" /></div>
-			<div><label for="blur">flou fond (px)</label><input id="blur" type="number" value="40" min="0" max="200" /></div>
-			<div>
-				<label for="instrument">instrumenté</label>
-				<input id="instrument" type="checkbox" checked style="width: auto" />
-			</div>
-			<div>
-				<label for="optimise">optimisé</label>
-				<input id="optimise" type="checkbox" checked style="width: auto" />
-			</div>
-			<button id="run">Lancer</button>
-		</div>
-
-		<div class="row" style="border-top: 1px solid #2a2a34; padding-top: 16px;">
-			<div>
-				<label for="compareMode">comparer</label>
-				<select id="compareMode" style="width: auto; min-width: 210px; background: #22222c; color: #e8e8ee; border: 1px solid #33333f; border-radius: 6px; padding: 6px 8px; font-size: 13px;">
-					<option value="pipeline">Pipeline : bufférisé vs sérialisé</option>
-					<option value="perf">Perf : optimisé vs naïf</option>
-					<option value="encode">Encodage : avec vs sans</option>
-					<option value="effects">Effets : activés vs coupés</option>
-					<option value="instruments">Mesure : instrumenté vs propre</option>
-				</select>
-			</div>
-			<button id="compare" style="background: #22222c; border: 1px solid #33333f">
-				Comparer A/B (8 exports)
-			</button>
-			<span id="compareNote" style="font-size: 12px; color: #8b8b9a; align-self: center;"></span>
-		</div>
-
-		<div class="stats">
-			<div class="stat hero"><div class="k">fps</div><div class="v" id="fps">—</div></div>
-			<div class="stat"><div class="k">par image</div><div class="v" id="perframe">—</div></div>
-			<div class="stat"><div class="k">composite</div><div class="v" id="render">—</div></div>
-			<div class="stat"><div class="k">décodage</div><div class="v" id="decode">—</div></div>
-			<div class="stat"><div class="k">encodage</div><div class="v" id="encode">—</div></div>
-			<div class="stat"><div class="k">frames</div><div class="v" id="progress">—</div></div>
-		</div>
-
-		<pre id="log"></pre>
-		<canvas id="stage"></canvas>
-		<video id="result" controls hidden></video>
-		<a id="download" hidden>télécharger poc.mp4</a>
-
-		<script type="module" src="./main.js"></script>
-	</body>
-</html>
diff --git a/poc/main.js b/poc/main.js
deleted file mode 100644
index a7b06d6544..0000000000
--- a/poc/main.js
+++ /dev/null
@@ -1,962 +0,0 @@
-// POC: two videos, one layout, three effects, full shader. Standalone.
-//
-// No Electron, no app code, no old paradigm: decode (mediabunny) → WebGPU →
-// encode (mediabunny) → an mp4 you can watch, and one number: fps.
-//
-// The layout is 40 lines of arithmetic written here, not imported: the point is
-// to prove the paradigm reconstructs the product, not to reuse what exists.
-
-import {
-	ALL_FORMATS,
-	BufferTarget,
-	Input,
-	Mp4OutputFormat,
-	Output,
-	UrlSource,
-	VideoSampleSink,
-} from "mediabunny";
-
-const OUT = { width: 1920, height: 1080, fps: 30 };
-const log = (msg) => {
-	document.querySelector("#log").textContent += `${msg}\n`;
-};
-const setStat = (id, value) => {
-	document.querySelector(`#${id}`).textContent = value;
-};
-
-// ---- evaluate: (scene, t) → the frame's geometry. Written from zero. --------
-//
-// Pure arithmetic, no GPU, no canvas. Everything the shader needs is decided
-// here, so the same function can drive a preview later without a second
-// implementation to keep in sync.
-
-const easeInOut = (x) => (x < 0.5 ? 4 * x * x * x : 1 - (-2 * x + 2) ** 3 / 2);
-
-/** Ramp 0→1→0 across a region, eased in and out over `ramp` seconds. */
-function regionStrength(t, start, end, ramp) {
-	if (t <= start || t >= end) return 0;
-	const inRamp = Math.min(1, (t - start) / ramp);
-	const outRamp = Math.min(1, (end - t) / ramp);
-	return easeInOut(Math.min(inRamp, outRamp));
-}
-
-const lerp = (a, b, t) => a + (b - a) * t;
-const clampAbs = (x, m) => Math.max(-m, Math.min(m, x));
-const lerpRect = (a, b, t) => ({
-	x: lerp(a.x, b.x, t),
-	y: lerp(a.y, b.y, t),
-	w: lerp(a.w, b.w, t),
-	h: lerp(a.h, b.h, t),
-});
-
-/** The base layout: recording centred with padding, webcam docked bottom-right. */
-function baseLayout(stage, padding) {
-	const s = 1 - (padding / 100) * 0.4;
-	const w = stage.width * s;
-	const h = stage.height * s;
-	const screen = { x: (stage.width - w) / 2, y: (stage.height - h) / 2, w, h };
-	const size = Math.round(stage.height * 0.22);
-	const margin = Math.round(stage.height * 0.04);
-	const webcam = {
-		x: stage.width - size - margin,
-		y: stage.height - size - margin,
-		w: size,
-		h: size,
-	};
-	return { screen, webcam };
-}
-
-/**
- * The whole timeline of this POC, as data.
- *
- * Two things move, and they are the two the product actually has:
- *  - a ZOOM on the recording: scale + focus point, eased in and out;
- *  - a LAYOUT ANIMATION on the webcam: it grows from the docked bubble to a
- *    large panel and its shape morphs from circle to rounded rect on the way.
- */
-function scene(stage, padding) {
-	return {
-		stage,
-		padding,
-		zooms: [
-			{ start: 1.0, end: 3.2, scale: 1.7, focus: { x: 0.62, y: 0.42 }, ramp: 0.55 },
-			{ start: 4.4, end: 6.5, scale: 2.3, focus: { x: 0.3, y: 0.7 }, ramp: 0.5 },
-		],
-		layoutMoves: [{ start: 2.4, end: 5.0, ramp: 0.6 }],
-	};
-}
-
-function evaluate(sc, t, prev) {
-	const base = baseLayout(sc.stage, sc.padding);
-
-	// --- zoom: strongest region wins, eased ---
-	let zoomScale = 1;
-	let focus = { x: 0.5, y: 0.5 };
-	let strength = 0;
-	for (const z of sc.zooms) {
-		const s = regionStrength(t, z.start, z.end, z.ramp);
-		if (s > strength) {
-			strength = s;
-			zoomScale = lerp(1, z.scale, s);
-			focus = z.focus;
-		}
-	}
-	// Scale about the focus point, then keep the recording covering the stage:
-	// a zoom that reveals the background behind the video is a bug, not a look.
-	const fx = base.screen.x + base.screen.w * focus.x;
-	const fy = base.screen.y + base.screen.h * focus.y;
-	const screen = {
-		x: fx - (fx - base.screen.x) * zoomScale,
-		y: fy - (fy - base.screen.y) * zoomScale,
-		w: base.screen.w * zoomScale,
-		h: base.screen.h * zoomScale,
-	};
-
-	// --- layout animation: the webcam grows into a panel and un-rounds ---
-	let move = 0;
-	for (const m of sc.layoutMoves) {
-		move = Math.max(move, regionStrength(t, m.start, m.end, m.ramp));
-	}
-	const panelW = Math.round(sc.stage.width * 0.34);
-	const panelH = Math.round(panelW * 0.75);
-	const margin = Math.round(sc.stage.height * 0.04);
-	const panel = {
-		x: sc.stage.width - panelW - margin,
-		y: sc.stage.height - panelH - margin,
-		w: panelW,
-		h: panelH,
-	};
-	const webcam = lerpRect(base.webcam, panel, move);
-	// Circle when docked (radius = half the bubble), rounded rect when grown.
-	const webcamRadius = lerp(Math.min(base.webcam.w, base.webcam.h) / 2, 26, move);
-
-	// --- motion blur: a VECTOR, along the camera's real travel ---
-	// The recording smears along how its centre moved since last frame, plus a
-	// term for the zoom scaling the content outward. A pan is diagonal; a
-	// horizontal-only smear would be wrong for most of what a screen demo does.
-	const cx = screen.x + screen.w / 2;
-	const cy = screen.y + screen.h / 2;
-	const wcx = webcam.x + webcam.w / 2;
-	const wcy = webcam.y + webcam.h / 2;
-	let screenBlur = { x: 0, y: 0 };
-	let webcamBlur = { x: 0, y: 0 };
-	if (prev) {
-		const k = 0.9;
-		screenBlur = {
-			x: clampAbs((cx - prev.cx) * k, 22),
-			y: clampAbs((cy - prev.cy) * k, 22),
-		};
-		webcamBlur = {
-			x: clampAbs((wcx - prev.wcx) * k, 18),
-			y: clampAbs((wcy - prev.wcy) * k, 18),
-		};
-	}
-
-	return {
-		screen,
-		webcam,
-		webcamRadius,
-		zoomScale,
-		screenBlur,
-		webcamBlur,
-		memo: { cx, cy, wcx, wcy },
-	};
-}
-
-// ---- the cursor: from the recorded trace, drawn synthetically ---------------
-//
-// The real product records positions + clicks and draws the cursor each frame
-// from that data — never baked into the video. This loads a REAL trace (the one
-// shipped with the screen recording) so the POC exercises the actual shape of the
-// data: normalised positions at irregular timestamps, and click/mouseup events.
-
-async function loadCursor(url) {
-	const doc = await (await fetch(url)).json();
-	// Dedup by timestamp (the trace repeats samples) and sort.
-	const byTime = new Map();
-	for (const s of doc.samples) byTime.set(s.timeMs, s);
-	const samples = [...byTime.values()].sort((a, b) => a.timeMs - b.timeMs);
-	const clicks = doc.samples.filter((s) => s.interactionType === "click").map((s) => s.timeMs);
-	return { samples, clicks };
-}
-
-/** Position (normalised to the recording) and click bounce at time t. */
-function cursorAt(trace, timeMs) {
-	const s = trace.samples;
-	if (s.length === 0) return null;
-	// Linear scan is fine at ~290 samples; a binary search is the same code later.
-	let i = 0;
-	while (i < s.length - 1 && s[i + 1].timeMs <= timeMs) i++;
-	const a = s[i];
-	const b = s[Math.min(i + 1, s.length - 1)];
-	const span = b.timeMs - a.timeMs;
-	const f = span > 0 ? Math.max(0, Math.min(1, (timeMs - a.timeMs) / span)) : 0;
-
-	// Click bounce: the pointer dips to 0.82 and springs back over ~140 ms after a
-	// real click — the same cue the app gives, driven by the recorded event.
-	let clickScale = 1;
-	for (const c of trace.clicks) {
-		const dt = timeMs - c;
-		if (dt >= 0 && dt < 140) {
-			const p = dt / 140;
-			clickScale = 1 - 0.18 * Math.sin(p * Math.PI);
-		}
-	}
-
-	return {
-		cx: lerp(a.cx, b.cx, f),
-		cy: lerp(a.cy, b.cy, f),
-		visible: a.visible !== false,
-		clickScale,
-	};
-}
-
-// ---- decode ----------------------------------------------------------------
-
-async function openVideo(url) {
-	const input = new Input({ source: new UrlSource(url), formats: ALL_FORMATS });
-	const track = await input.getPrimaryVideoTrack();
-	if (!track) throw new Error(`no video track in ${url}`);
-	const sink = new VideoSampleSink(track);
-	return { input, track, sink };
-}
-
-// ---- run -------------------------------------------------------------------
-
-async function run(override = {}) {
-	const started = performance.now();
-	// A hidden tab is a throttled tab. Chromium de-prioritises everything in one —
-	// the GPU work included — and clamps chained timers to a second. Measured
-	// here: the same code that cruises at 58 fps visible reports 6.0 fps hidden,
-	// on BOTH arms, with a 401% spread. Every number taken from a background tab
-	// is fiction, so this refuses rather than reports.
-	if (document.hidden) {
-		throw new Error(
-			"tab is hidden — Chromium throttles background tabs. Bring it to the front and re-run.",
-		);
-	}
-	document.querySelector("#run").disabled = true;
-	log("opening sources…");
-
-	const [screen, webcam, cursor] = await Promise.all([
-		openVideo("media/screen.mp4"),
-		openVideo("media/webcam.mp4"),
-		loadCursor("media/cursor.json"),
-	]);
-	log(`cursor: ${cursor.samples.length} samples, ${cursor.clicks.length} clicks`);
-	const seconds = Number(document.querySelector("#seconds").value);
-	const screenDuration = await screen.track.computeDuration();
-	const duration = Math.min(seconds, screenDuration);
-	const totalFrames = Math.floor(duration * OUT.fps);
-	log(
-		`screen ${screen.track.displayWidth}x${screen.track.displayHeight} · ${screenDuration.toFixed(1)}s`,
-	);
-	log(`webcam ${webcam.track.displayWidth}x${webcam.track.displayHeight}`);
-	log(`rendering ${totalFrames} frames @ ${OUT.fps}fps (${duration.toFixed(1)}s)`);
-
-	// ---- GPU ----
-	if (!navigator.gpu) throw new Error("WebGPU unavailable");
-	const adapter = await navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
-	// timestamp-query is the only honest way to price the shader: a CPU timer
-	// around submit() measures SUBMISSION, and the work lands on whoever syncs
-	// next. These are counters the GPU writes itself, around the pass.
-	const canTimestamp = adapter.features.has("timestamp-query");
-	const device = await adapter.requestDevice({
-		requiredFeatures: canTimestamp ? ["timestamp-query"] : [],
-	});
-	const info = adapter.info ?? {};
-	log(`gpu: ${info.vendor ?? "?"} ${info.architecture ?? ""} · timestamps: ${canTimestamp}`);
-
-	const querySet = canTimestamp ? device.createQuerySet({ type: "timestamp", count: 2 }) : null;
-	const resolveBuffer = canTimestamp
-		? device.createBuffer({
-				size: 16,
-				usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
-			})
-		: null;
-	const readBuffer = canTimestamp
-		? device.createBuffer({ size: 16, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ })
-		: null;
-
-	// OffscreenCanvas: no document, no presentation, no compositor.
-	//
-	// This is a measurement decision, not a detail. A canvas in the page is
-	// PRESENTED every frame — the browser composites 2 Mpx into the layout and the
-	// swapchain waits on the display's refresh. Measured here: 34.9 ms/frame of
-	// fixed cost with every effect switched OFF, eight times the effects
-	// themselves. An export presents nothing to anyone, so a measurement that pays
-	// for presentation is measuring a different program.
-	const canvas = new OffscreenCanvas(OUT.width, OUT.height);
-	const ctx = canvas.getContext("webgpu");
-	const format = navigator.gpu.getPreferredCanvasFormat();
-	ctx.configure({ device, format, alphaMode: "opaque" });
-
-	const previewCanvas = document.querySelector("#stage");
-	previewCanvas.width = 640;
-	previewCanvas.height = 360;
-	const preview = previewCanvas.getContext("2d");
-
-	const code = await (await fetch("composite.wgsl")).text();
-	const module = device.createShaderModule({ code });
-	device.pushErrorScope("validation");
-
-	// One explicit layout for every pass, so a shader that happens not to sample
-	// bgTex does not silently get a different bind group. `auto` derives the
-	// layout from what the entry point USES, which makes the layout an accident of
-	// dead-code elimination.
-	const bindGroupLayout = device.createBindGroupLayout({
-		entries: [
-			{ binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: {} },
-			{ binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: {} },
-			{ binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {} },
-			{ binding: 3, visibility: GPUShaderStage.FRAGMENT, externalTexture: {} },
-			{ binding: 4, visibility: GPUShaderStage.FRAGMENT, texture: {} },
-		],
-	});
-	const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] });
-
-	// Straight-alpha "over": the compositor's only blend.
-	const OVER = {
-		color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
-		alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
-	};
-	const makePass = (vs, fs, blend) =>
-		device.createRenderPipeline({
-			label: fs,
-			layout: pipelineLayout,
-			vertex: { module, entryPoint: vs },
-			fragment: { module, entryPoint: fs, targets: [{ format, ...(blend ? { blend } : {}) }] },
-			primitive: { topology: "triangle-list" },
-		});
-
-	// Five passes, each a quad sized to its element. The rasterizer clips whatever
-	// leaves the stage — which, during a zoom, is most of the recording.
-	const passes = {
-		background: makePass("vsFull", "fsBackground", null),
-		screenShadow: makePass("vsScreenShadow", "fsScreenShadow", OVER),
-		screen: makePass("vsScreen", "fsScreen", OVER),
-		webcamShadow: makePass("vsWebcamShadow", "fsWebcamShadow", OVER),
-		webcam: makePass("vsWebcam", "fsWebcam", OVER),
-		cursor: makePass("vsCursor", "fsCursor", OVER),
-	};
-
-	// The bake runs before any video exists, so it gets a layout of its own: the
-	// uniforms and nothing else.
-	const bakeLayout = device.createBindGroupLayout({
-		entries: [
-			{ binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: {} },
-		],
-	});
-	const bgPipeline = device.createRenderPipeline({
-		label: "bake",
-		layout: device.createPipelineLayout({ bindGroupLayouts: [bakeLayout] }),
-		vertex: { module, entryPoint: "vsFull" },
-		fragment: { module, entryPoint: "fsBake", targets: [{ format: "rgba8unorm" }] },
-		primitive: { topology: "triangle-list" },
-	});
-	const bgTexture = device.createTexture({
-		size: [OUT.width, OUT.height],
-		format: "rgba8unorm",
-		usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
-	});
-	const shaderError = await device.popErrorScope();
-	if (shaderError) throw new Error(`shader: ${shaderError.message}`);
-
-	const sampler = device.createSampler({ magFilter: "linear", minFilter: "linear" });
-	// 5 vec4 = 80 bytes. All-vec4 on purpose: WGSL pads mixed structs and the CPU
-	// packing has to reproduce the holes exactly — get one offset wrong and the
-	// shader reads a radius where a rect belongs, draws nothing, and reports no
-	// error at all.
-	const uniforms = new Float32Array(32);
-	const uniformBuffer = device.createBuffer({
-		size: uniforms.byteLength,
-		usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-	});
-
-	// ---- encode ----
-	const output = new Output({ format: new Mp4OutputFormat(), target: new BufferTarget() });
-	const { CanvasSource, QUALITY_HIGH } = await import("mediabunny");
-	const source = new CanvasSource(canvas, { codec: "avc", bitrate: QUALITY_HIGH });
-	output.addVideoTrack(source, { frameRate: OUT.fps });
-	await output.start();
-
-	const sc = scene(OUT, Number(document.querySelector("#padding").value));
-	// effectsOn === false forces the effects OFF (not just absent) so the "effects
-	// on vs off" comparison isolates their cost against the same everything-else.
-	const effectsOn = override.effectsOn ?? true;
-	const shadowIntensity = effectsOn ? Number(document.querySelector("#shadow").value) : 0;
-	const bgBlur = effectsOn ? Number(document.querySelector("#blur").value) : 0;
-	const camAspect = webcam.track.displayWidth / webcam.track.displayHeight;
-	let memo = null;
-	let curMemo = null;
-
-	// Bake the background. Once, here — not 210 times inside the loop.
-	uniforms.set([OUT.width, OUT.height, 0, 0], 0);
-	uniforms.set([shadowIntensity, bgBlur, 16, 22], 12);
-	device.queue.writeBuffer(uniformBuffer, 0, uniforms);
-	{
-		const enc = device.createCommandEncoder();
-		const pass = enc.beginRenderPass({
-			colorAttachments: [
-				{
-					view: bgTexture.createView(),
-					clearValue: { r: 0, g: 0, b: 0, a: 1 },
-					loadOp: "clear",
-					storeOp: "store",
-				},
-			],
-		});
-		pass.setPipeline(bgPipeline);
-		pass.setBindGroup(
-			0,
-			device.createBindGroup({
-				layout: bakeLayout,
-				entries: [{ binding: 0, resource: { buffer: uniformBuffer } }],
-			}),
-		);
-		pass.draw(3);
-		pass.end();
-		device.queue.submit([enc.finish()]);
-	}
-
-	// ---- decode: forward streams, not seeks ----
-	// getSample(t) per frame is a random-access SEEK per frame: on a long-GOP
-	// screen recording that means re-decoding from the last keyframe, every time.
-	// Measured at 122 ms/frame — 3x the cost of everything else combined. These
-	// videos are read start to end, so read them start to end: two generators,
-	// each advanced to the frame the output clock is asking for.
-	const screenStream = screen.sink.samples(0, duration);
-	const webcamStream = webcam.sink.samples(0, duration);
-	const nextFrom = async (stream, holder, t) => {
-		// Advance while the NEXT sample still starts at or before t.
-		while (
-			!holder.done &&
-			(!holder.current || holder.current.timestamp + holder.current.duration <= t)
-		) {
-			const { value, done } = await stream.next();
-			if (done) {
-				holder.done = true;
-				break;
-			}
-			holder.current?.close();
-			holder.current = value;
-		}
-		return holder.current ?? null;
-	};
-	const screenHolder = { current: null, done: false };
-	const webcamHolder = { current: null, done: false };
-
-	// ---- the loop ----
-	// Every phase is timed on its own, and the whole frame is recorded, because
-	// two questions need different data: "what does a frame cost once warm" is a
-	// distribution, not a mean, and "where does the frame go" is a breakdown.
-	//
-	// INSTRUMENTED vs CLEAN, because the instruments are not free and two of them
-	// change the very thing they measure:
-	//   - onSubmittedWorkDone() per frame is a FENCE. It is the only way to bill
-	//     the GPU honestly, and it also forbids decode/composite/encode from ever
-	//     overlapping — a cost the real loop would not pay.
-	//   - mapAsync() to read the timestamps is a GPU→CPU sync, per frame.
-	// So the clean pass keeps the same work and drops both, and fps is compared
-	// across the two. If they disagree, the breakdown describes a program that
-	// only exists while being measured.
-	const instrumented = override.instrumented ?? document.querySelector("#instrument").checked;
-	const optimised = override.optimised ?? document.querySelector("#optimise").checked;
-	const encodeOn = override.encode ?? true;
-	// How many encodes may be in flight before composite blocks.
-	//
-	// Default 1 (serialised) BECAUSE IT IS FASTER HERE, measured: buffered depth-4
-	// throughput 49 fps vs serialised 79 fps on this iGPU (spread 7-11%, so real).
-	// §11's "pipeline, don't await" assumed overlap helps; on an integrated GPU the
-	// compositor and the hardware H.264 encoder share one memory bus, so running
-	// them at once makes them contend rather than parallelise — serialising lets
-	// each have the full bandwidth in turn. The pipeline stays reachable
-	// (queueDepth override) because a DISCRETE GPU, with its own VRAM and separate
-	// encoder silicon, may flip the result — untested (that is bench G3).
-	const queueDepth = instrumented ? 1 : (override.queueDepth ?? 1);
-	const inflight = [];
-	const frames = [];
-	const t0 = performance.now();
-	// The steady-state window starts after the first quarter (warm-up). We time it
-	// on the WALL, from here to after the final drain+flush — not per loop
-	// iteration — because with the pipeline the loop does not wait for the work:
-	// submit() is non-blocking and encode is only awaited on backpressure. A
-	// per-frame timer then measures an empty loop distributing orders (naive
-	// composite is slower, so it feeds the encoder slower, so the loop blocks LESS
-	// and reads FASTER — 588 fps of nothing). True throughput is frames ÷ the wall
-	// until they have actually completed, which finalize() forces.
-	const warmStart = Math.ceil(totalFrames / 4);
-	let warmWall = 0;
-	let rendered = 0;
-
-	for (let i = 0; i < totalFrames; i++) {
-		if (i === warmStart) warmWall = performance.now();
-		const t = i / OUT.fps;
-		const fStart = performance.now();
-		const p = {};
-		const mark = () => (instrumented ? performance.now() : 0);
-
-		let m = mark();
-		const screenSample = await nextFrom(screenStream, screenHolder, t);
-		const webcamSample = await nextFrom(webcamStream, webcamHolder, t);
-		p.decode = mark() - m;
-		if (!screenSample) break;
-
-		// toVideoFrame + importExternalTexture: the decode→GPU seam. Timed apart
-		// because "zero copy" is a claim, and this is where it would fail.
-		m = mark();
-		const screenFrame = screenSample.toVideoFrame();
-		const webcamFrame = webcamSample ? webcamSample.toVideoFrame() : null;
-		const screenTex = device.importExternalTexture({ source: screenFrame });
-		const webcamTex = device.importExternalTexture({ source: webcamFrame ?? screenFrame });
-		p.import = mark() - m;
-
-		m = mark();
-		const f = evaluate(sc, t, memo);
-		memo = f.memo;
-
-		// The cursor: interpolate the recorded trace, then place it in the SCREEN's
-		// coordinate space, so it rides the zoom for free — its position is carried
-		// through the same rect the recording is.
-		const cur = cursorAt(cursor, t * 1000);
-		const curX = f.screen.x + (cur?.cx ?? 0) * f.screen.w;
-		const curY = f.screen.y + (cur?.cy ?? 0) * f.screen.h;
-		const curSize = OUT.height * 0.05;
-		let curBlurX = 0;
-		let curBlurY = 0;
-		if (cur && curMemo) {
-			curBlurX = clampAbs((curX - curMemo.x) * 0.8, 30);
-			curBlurY = clampAbs((curY - curMemo.y) * 0.8, 30);
-		}
-		curMemo = cur ? { x: curX, y: curY } : null;
-		const curVisible = !!cur && cur.visible;
-
-		// Field n at float 4n — the struct is all-vec4 so this stays true.
-		uniforms.set([OUT.width, OUT.height, t, 28], 0); // stage | time | radius
-		uniforms.set([f.screen.x, f.screen.y, f.screen.w, f.screen.h], 4);
-		uniforms.set([f.webcam.x, f.webcam.y, f.webcam.w, f.webcam.h], 8);
-		uniforms.set([shadowIntensity, bgBlur, 16, 22], 12); // intensity | bgBlur | shadowOffsetY | sigma
-		uniforms.set([f.webcamRadius, 0, camAspect, optimised ? 1 : 0], 16); // radius | - | coverScale | opt
-		uniforms.set([f.screenBlur.x, f.screenBlur.y, f.webcamBlur.x, f.webcamBlur.y], 20); // mb
-		uniforms.set([curX, curY, curSize, curVisible ? 1 : 0], 24); // cursor
-		uniforms.set([curBlurX, curBlurY, cur?.clickScale ?? 1, 0], 28); // cursorFx
-		device.queue.writeBuffer(uniformBuffer, 0, uniforms);
-		const bind = device.createBindGroup({
-			layout: bindGroupLayout,
-			entries: [
-				{ binding: 0, resource: { buffer: uniformBuffer } },
-				{ binding: 1, resource: sampler },
-				{ binding: 2, resource: screenTex },
-				{ binding: 3, resource: webcamTex },
-				{ binding: 4, resource: bgTexture.createView() },
-			],
-		});
-		p.evaluate = mark() - m;
-
-		m = mark();
-		const encoder = device.createCommandEncoder();
-		const view = ctx.getCurrentTexture().createView();
-		p.acquire = mark() - m;
-
-		m = mark();
-		const useQueries = instrumented && querySet;
-		const pass = encoder.beginRenderPass({
-			colorAttachments: [
-				{ view, clearValue: { r: 0, g: 0, b: 0, a: 1 }, loadOp: "clear", storeOp: "store" },
-			],
-			...(useQueries
-				? { timestampWrites: { querySet, beginningOfPassWriteIndex: 0, endOfPassWriteIndex: 1 } }
-				: {}),
-		});
-		// CULLING, on the CPU, before anything is submitted.
-		//
-		// The cheapest fragment is the one never dispatched. Two tests, both from
-		// the rects evaluate() already produced:
-		//  - the recording covers the stage (every zoom does): nothing underneath
-		//    can show, so the background and its shadow are not drawn at all. The
-		//    test insets by the corner radius, because a rounded corner is where
-		//    the background WOULD peek through.
-		//  - the webcam is entirely off-stage: it and its shadow are not drawn.
-		const r = f.screen;
-		const rad = 28;
-		const screenCoversStage =
-			optimised &&
-			r.x + rad <= 0 &&
-			r.y + rad <= 0 &&
-			r.x + r.w - rad >= OUT.width &&
-			r.y + r.h - rad >= OUT.height;
-		const w = f.webcam;
-		const webcamVisible =
-			!optimised || (w.x < OUT.width && w.y < OUT.height && w.x + w.w > 0 && w.y + w.h > 0);
-
-		pass.setBindGroup(0, bind);
-		if (!screenCoversStage) {
-			pass.setPipeline(passes.background);
-			pass.draw(6);
-			pass.setPipeline(passes.screenShadow);
-			pass.draw(6);
-		}
-		pass.setPipeline(passes.screen);
-		pass.draw(6);
-		if (webcamVisible) {
-			pass.setPipeline(passes.webcamShadow);
-			pass.draw(6);
-			pass.setPipeline(passes.webcam);
-			pass.draw(6);
-		}
-		// The cursor, on top of everything — drawn each frame from the trace, culled
-		// when the recorded position is off-stage.
-		if (curVisible && curX > -curSize && curY > -curSize && curX < OUT.width && curY < OUT.height) {
-			pass.setPipeline(passes.cursor);
-			pass.draw(6);
-		}
-		pass.end();
-		if (useQueries) {
-			encoder.resolveQuerySet(querySet, 0, 2, resolveBuffer, 0);
-			if (readBuffer.mapState === "unmapped")
-				encoder.copyBufferToBuffer(resolveBuffer, 0, readBuffer, 0, 16);
-		}
-		device.queue.submit([encoder.finish()]);
-		p.submit = mark() - m;
-
-		// The fence: everything above only QUEUED work, this is where it executes.
-		// Instrumented only — it is what makes the breakdown honest, and it is also
-		// what stops the pipeline from overlapping anything.
-		if (instrumented) {
-			m = performance.now();
-			await device.queue.onSubmittedWorkDone();
-			p.fence = performance.now() - m;
-
-			// What the GPU says about itself: the pass's duration in ns, written by
-			// the GPU around the pass. mapAsync is a GPU→CPU sync, so this too only
-			// exists while measuring.
-			if (querySet && readBuffer.mapState === "unmapped") {
-				await readBuffer.mapAsync(GPUMapMode.READ);
-				const ts = new BigUint64Array(readBuffer.getMappedRange().slice(0));
-				readBuffer.unmap();
-				p.gpuPass = Number(ts[1] - ts[0]) / 1e6;
-			}
-		}
-
-		// ENCODE — pipelined, not awaited per frame.
-		//
-		// source.add snapshots the canvas synchronously (new VideoSample(canvas)),
-		// and everything rides one GPU queue, so submission order already guarantees
-		// each encoded frame reflects its own composite — no fence needed for
-		// correctness. Awaiting add() every frame only enforces BACKPRESSURE, and
-		// doing it per frame is what serialised the loop: composite waited on the
-		// encoder accepting the previous frame. Keep `queueDepth` frames in flight
-		// instead, so the hardware encoder runs concurrently with the next
-		// composite. This is §11 — pipeline, don't await.
-		m = mark();
-		if (encodeOn) {
-			const addP = source.add(t, 1 / OUT.fps);
-			if (queueDepth <= 1) {
-				await addP;
-			} else {
-				inflight.push(addP);
-				if (inflight.length >= queueDepth) await inflight.shift();
-			}
-		}
-		p.encode = mark() - m;
-
-		// The decode VideoFrames are ours; the samples belong to the streams, which
-		// close them when they advance. Safe to close after submit: Chromium holds
-		// its own reference to an imported external texture until the submit that
-		// used it completes.
-		screenFrame.close();
-		webcamFrame?.close();
-
-		p.total = performance.now() - fStart;
-		frames.push(p);
-		rendered++;
-		if (i % 15 === 0) {
-			setStat("progress", `${i}/${totalFrames}`);
-			// A 640px preview every 15 frames. OFF the clock — the frame's timer has
-			// already stopped — and it never touches the render path.
-			preview.drawImage(canvas, 0, 0, previewCanvas.width, previewCanvas.height);
-			// Yield through a MessageChannel, not setTimeout: a chained setTimeout is
-			// clamped to 1000 ms in a background tab, which would put eight seconds of
-			// pure waiting into a four-second export's wall.
-			await new Promise((r) => {
-				const ch = new MessageChannel();
-				ch.port1.onmessage = () => r();
-				ch.port2.postMessage(0);
-			});
-		}
-	}
-
-	// Drain the encoder pipeline, then flush+mux: only after finalize() has all
-	// frames actually completed. The throughput window closes HERE, not at the end
-	// of the loop, because the loop returns before the GPU and the encoder are
-	// done.
-	if (inflight.length) await Promise.all(inflight);
-	await output.finalize();
-	const endWall = performance.now();
-	const wallMs = endWall - t0;
-	// The honest steady-state throughput: frames rendered after warm-up, over the
-	// wall time until they are fully composited, encoded and muxed.
-	const warmFrames = rendered - warmStart;
-	const throughputFps =
-		warmWall > 0 ? warmFrames / ((endWall - warmWall) / 1000) : rendered / (wallMs / 1000);
-
-	// ---- report ----
-	//
-	// Average fps answers "how long did THIS export take". Cruise fps answers "how
-	// fast does it run" — the number that compares across exports. A short export
-	// amortises the first frames' one-off costs (pipeline warm-up, first
-	// allocations, JIT) over few frames, so the mean drags. Both are reported, and
-	// the gap between them IS the startup cost.
-	const median = (xs) => {
-		const s = [...xs].sort((a, b) => a - b);
-		return s.length % 2 ? s[(s.length - 1) / 2] : (s[s.length / 2 - 1] + s[s.length / 2]) / 2;
-	};
-	const totals = frames.map((f) => f.total);
-	// Cruise = the steady state: drop the first quarter, then take the MEDIAN, so
-	// one scheduler hiccup cannot move the number.
-	const warm = frames.slice(warmStart);
-	const cruiseMs = median(warm.map((f) => f.total));
-	const cruiseFps = 1000 / cruiseMs;
-	const avgFps = rendered / (wallMs / 1000);
-
-	// Throughput is the headline. Cruise (per-frame loop time) is kept for the
-	// instrumented breakdown, where the fence makes each iteration wait for its own
-	// work — there it equals throughput; under the pipeline it does not.
-	setStat("fps", throughputFps.toFixed(1));
-	setStat("progress", `${rendered}/${totalFrames}`);
-	setStat("perframe", `${(1000 / throughputFps).toFixed(1)} ms`);
-	// `?? 0`: the clean pass has no phase timers by construction — that is what
-	// makes it clean. Reading them back as undefined is not an error, it is the
-	// point.
-	setStat("render", instrumented ? `${median(warm.map((f) => f.fence ?? 0)).toFixed(1)} ms` : "—");
-	setStat("decode", instrumented ? `${median(warm.map((f) => f.decode ?? 0)).toFixed(1)} ms` : "—");
-	setStat("encode", instrumented ? `${median(warm.map((f) => f.encode ?? 0)).toFixed(1)} ms` : "—");
-
-	log(
-		`\n=== [${instrumented ? "INSTRUMENTED" : "CLEAN"}] throughput ${throughputFps.toFixed(1)} fps — ${warmFrames} frames in ${((endWall - warmWall) / 1000).toFixed(2)}s (wall, incl. drain+mux) ===`,
-	);
-	log(
-		`per-loop cruise ${cruiseFps.toFixed(1)} fps (${cruiseMs.toFixed(1)} ms) — under the pipeline this measures the LOOP, not completion; throughput above is the honest number.`,
-	);
-	log(
-		`average ${avgFps.toFixed(1)} fps over all ${rendered} frames (${(wallMs / 1000).toFixed(2)}s wall)`,
-	);
-	log(
-		`first frames: ${totals
-			.slice(0, 4)
-			.map((x) => `${x.toFixed(0)}ms`)
-			.join(" · ")}`,
-	);
-	const drag = totals.reduce((a, b) => a + b, 0) - cruiseMs * totals.length;
-	log(
-		`one-off cost inside the loop: ${drag.toFixed(0)} ms total → ${(drag / rendered).toFixed(1)} ms/frame of drag on this export`,
-	);
-	log(
-		`setup before the loop: ${((t0 - started) / 1000).toFixed(2)}s (open sources, decoder init, pipeline, encoder)`,
-	);
-
-	if (!instrumented) {
-		log("\n(clean pass: no fence, no timestamp readback, no phase timers.");
-		log(" fps is the only number this pass can honestly report — and it is the");
-		log(" one that says what the loop actually does when nobody is watching.)");
-	} else {
-		log("\n--- where a cruise frame goes (median ms) ---");
-		for (const k of ["decode", "import", "evaluate", "acquire", "submit", "fence", "encode"]) {
-			const v = median(warm.map((f) => f[k] ?? 0));
-			const pct = (v / cruiseMs) * 100;
-			log(
-				`${k.padEnd(9)}${v.toFixed(1).padStart(6)} ms  ${"█".repeat(Math.round(pct / 2)).padEnd(50)}${pct.toFixed(0)}%`,
-			);
-		}
-		if (frames[0]?.gpuPass !== undefined) {
-			const gpu = median(warm.map((f) => f.gpuPass ?? 0));
-			log(`\nGPU pass itself: ${gpu.toFixed(2)} ms — measured BY the GPU, around the pass.`);
-			log(
-				`${(cruiseMs - gpu).toFixed(1)} ms of the ${cruiseMs.toFixed(1)} ms frame is not the shader.`,
-			);
-		}
-		log("\nNOTE: this pass paid for its own instruments — a fence and a buffer map");
-		log("per frame. Re-run with `instrumenté` off: if the fps moves, the breakdown");
-		log("above describes a program that only exists while being measured.");
-	}
-
-	const blob = new Blob([output.target.buffer], { type: "video/mp4" });
-	const url = URL.createObjectURL(blob);
-	const player = document.querySelector("#result");
-	player.src = url;
-	player.hidden = false;
-	const dl = document.querySelector("#download");
-	dl.href = url;
-	dl.download = "poc.mp4";
-	dl.hidden = false;
-
-	// On disk too: a blob URL dies with the tab, and the output has to be
-	// watchable outside this page.
-	const written = await fetch("/save?name=poc.mp4", { method: "POST", body: blob }).then((r) =>
-		r.text(),
-	);
-	log(`output: ${(blob.size / 1e6).toFixed(1)} MB → ${written}`);
-
-	// Give it ALL back. A run that leaks its device is a run that poisons the next
-	// one: six back-to-back runs kept six GPU devices, six decoder pipelines and
-	// six encoders alive, and the rate decayed 19.9 → 8.6 → 7.5 fps across an
-	// interleaved comparison. That decay is not the machine drifting, it is this
-	// function forgetting — and it invalidated the very A/B it was there to serve.
-	screenHolder.current?.close();
-	webcamHolder.current?.close();
-	await screenStream.return?.();
-	await webcamStream.return?.();
-	screen.input.dispose();
-	webcam.input.dispose();
-	bgTexture.destroy();
-	device.destroy();
-
-	document.querySelector("#run").disabled = false;
-	return { cruiseMs, cruiseFps, avgFps, throughputFps, instrumented };
-}
-
-/**
- * Interleaved A/B/A/B, because an effect can only be told apart from drift.
- *
- * Two identical runs measured 34.8 and 28.3 fps on this machine — 23% apart,
- * which is the size of the effects under test. Sequential arms therefore prove
- * nothing: they alternate so drift shows up as a run disagreeing with its OWN
- * repeat instead of masquerading as the change. Same rule, and same reason, as
- * the app's export bench.
- *
- * Both shader variants live in the same module, chosen by a uniform, so the two
- * arms differ by that uniform and nothing else — no reload, no recompile, no
- * second session.
- */
-// Every A/B this POC can run, each naming EXACTLY the two things it compares and
-// what one run() override turns one arm into the other. Each holds everything
-// else fixed, so the difference is the named lever and nothing else.
-const COMPARISONS = {
-	perf: {
-		title: "Perf : optimisé vs naïf",
-		a: { label: "optimisé", over: { optimised: true, instrumented: false } },
-		b: { label: "naïf", over: { optimised: false, instrumented: false } },
-		note: "fond cuit + culling, vs fond recalculé + tout dessiné. Même image.",
-	},
-	effects: {
-		title: "Effets : activés vs coupés",
-		a: { label: "effets ON", over: { effectsOn: true, optimised: true, instrumented: false } },
-		b: { label: "effets OFF", over: { effectsOn: false, optimised: true, instrumented: false } },
-		note: "ombre + flou de fond présents, vs à zéro. Le prix des effets eux-mêmes.",
-	},
-	pipeline: {
-		title: "Pipeline : bufférisé vs sérialisé",
-		a: { label: "bufférisé", over: { queueDepth: 4, instrumented: false, optimised: true } },
-		b: { label: "sérialisé", over: { queueDepth: 1, instrumented: false, optimised: true } },
-		note: "encodage recouvert (4 en vol) vs attendu à chaque image. Le levier §11.",
-	},
-	encode: {
-		title: "Encodage : avec vs sans",
-		a: { label: "avec encodage", over: { encode: true, instrumented: false, optimised: true } },
-		b: { label: "sans encodage", over: { encode: false, instrumented: false, optimised: true } },
-		note: "compose + encode vs compose seul. Ce que coûte l'encodeur matériel.",
-	},
-	instruments: {
-		title: "Mesure : instrumenté vs propre",
-		a: { label: "instrumenté", over: { instrumented: true, optimised: true } },
-		b: { label: "propre", over: { instrumented: false, optimised: true } },
-		note: "fence + lecture des timestamps par image, vs rien. Le coût de la mesure.",
-	},
-};
-
-/**
- * Interleaved A/B/A/B, because an effect can only be told apart from drift.
- *
- * Two identical runs measured 34.8 and 28.3 fps on this machine — 23% apart,
- * which is the size of the effects under test. Sequential arms therefore prove
- * nothing: they alternate so drift shows up as a run disagreeing with its OWN
- * repeat instead of masquerading as the change. Same rule, and same reason, as
- * the app's export bench. The shader variants all live in one module, chosen by a
- * uniform, so an arm differs from its pair by that uniform and nothing else.
- */
-async function compare(rounds = 3) {
-	const spec = COMPARISONS[document.querySelector("#compareMode").value] ?? COMPARISONS.perf;
-	const median = (xs) => {
-		const s = [...xs].sort((a, b) => a - b);
-		return s.length % 2 ? s[(s.length - 1) / 2] : (s[s.length / 2 - 1] + s[s.length / 2]) / 2;
-	};
-	const spread = (xs) => (Math.max(...xs) - Math.min(...xs)) / median(xs);
-	const arms = [
-		{ ...spec.a, runs: [] },
-		{ ...spec.b, runs: [] },
-	];
-
-	// Round 0 is thrown away. Both arms climb monotonically across the first
-	// rounds — 15.0 → 28.4 → 33.3 — which is the browser and the GPU waking up,
-	// not the arms differing. Keeping it put a 64% spread on a 23% effect and
-	// voided the comparison by itself.
-	for (let r = 0; r <= rounds; r++) {
-		for (const arm of arms) {
-			const res = await run(arm.over);
-			if (r > 0) arm.runs.push(res.throughputFps);
-		}
-	}
-
-	document.querySelector("#log").textContent = "";
-	log(`=== ${spec.title} — A/B interleavé, ${rounds} tours + 1 chauffe ===`);
-	log(`${spec.note}\n`);
-	for (const arm of arms) {
-		log(
-			`${arm.label.padEnd(13)} débit ${median(arm.runs).toFixed(1).padStart(5)} fps   spread ${(spread(arm.runs) * 100).toFixed(0)}%   ${arm.runs.map((x) => x.toFixed(1)).join(" / ")}`,
-		);
-	}
-	const [A, B] = arms;
-	const gain = median(A.runs) - median(B.runs);
-	const gainPct = (gain / median(B.runs)) * 100;
-	const worst = Math.max(spread(A.runs), spread(B.runs)) * 100;
-	log(
-		`\n${A.label} vs ${B.label}: ${gain > 0 ? "+" : ""}${gain.toFixed(1)} fps (${gainPct.toFixed(0)}%)`,
-	);
-	// Two gates, not one. The old gate only checked spread against the EFFECT, so a
-	// big effect waved through big noise — a 66% spread "held" against a 205% gain
-	// while the tab was throttled and the arm swung 117→235 fps. An ABSOLUTE
-	// threshold catches that: above ~15% same-arm spread the machine is not steady
-	// enough to trust the magnitude, whatever the effect size. (The app's export
-	// bench uses 10%; this browser setup is noisier, so 15%.)
-	const SPREAD_LIMIT = 15;
-	if (worst >= SPREAD_LIMIT) {
-		log(
-			`\n!! VOID : spread intra-bras ${worst.toFixed(0)}% > ${SPREAD_LIMIT}% — la machine dérive.` +
-				`\n   La DIRECTION peut tenir (regarde si un bras gagne à chaque tour), mais` +
-				`\n   le CHIFFRE ne vaut rien. Ferme les autres apps GPU, secteur branché, refais.`,
-		);
-	} else if (worst >= Math.abs(gainPct)) {
-		log(`\n!! VOID : spread intra-bras ${worst.toFixed(0)}%, aussi grand que l'effet — run muet.`);
-	} else {
-		log(
-			`\nspread intra-bras ${worst.toFixed(0)}% < ${SPREAD_LIMIT}% et < l'effet — le résultat tient.`,
-		);
-	}
-	setStat("fps", median(A.runs).toFixed(1));
-}
-
-document.querySelector("#run").addEventListener("click", () => {
-	document.querySelector("#log").textContent = "";
-	run().catch((error) => {
-		log(`\nFAILED: ${error.message}`);
-		console.error(error);
-		document.querySelector("#run").disabled = false;
-	});
-});
-
-document.querySelector("#compare").addEventListener("click", () => {
-	document.querySelector("#log").textContent = "comparaison en cours, patientez…\n";
-	compare().catch((error) => {
-		log(`\nFAILED: ${error.message}`);
-		console.error(error);
-		document.querySelector("#run").disabled = false;
-	});
-});
-
-// Show the selected comparison's plain-language note next to the dropdown.
-const modeSelect = document.querySelector("#compareMode");
-const updateNote = () => {
-	document.querySelector("#compareNote").textContent = COMPARISONS[modeSelect.value]?.note ?? "";
-};
-modeSelect.addEventListener("change", updateNote);
-updateNote();
diff --git a/poc/vite.config.js b/poc/vite.config.js
deleted file mode 100644
index cc87d13056..0000000000
--- a/poc/vite.config.js
+++ /dev/null
@@ -1,39 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const here = dirname(fileURLToPath(import.meta.url));
-
-/**
- * POST /save?name=x → poc/out/x.
- *
- * The output has to be watchable on disk, not just a blob URL that dies with the
- * tab. Dev-only, and it writes exactly one directory.
- */
-const save = {
-	name: "poc-save",
-	configureServer(server) {
-		server.middlewares.use("/save", (req, res) => {
-			const name = new URL(req.url, "http://x").searchParams.get("name") ?? "out.bin";
-			const chunks = [];
-			req.on("data", (c) => chunks.push(c));
-			req.on("end", () => {
-				const body = Buffer.concat(chunks);
-				const dir = join(here, "out");
-				mkdirSync(dir, { recursive: true });
-				const file = join(dir, name.replace(/[^\w.-]/g, "_"));
-				writeFileSync(file, body);
-				console.log(`[poc] wrote ${file} (${body.length} bytes)`);
-				res.end(file);
-			});
-		});
-	},
-};
-
-// The POC serves itself. Nothing here knows about the app: no aliases, no
-// electron plugin, no shared config — the isolation is the point.
-export default {
-	root: here,
-	plugins: [save],
-	server: { port: 5210, strictPort: true },
-};
diff --git a/public/os-preview-sample.mp4 b/public/os-preview-sample.mp4
deleted file mode 100644
index 795ccf7d0a..0000000000
Binary files a/public/os-preview-sample.mp4 and /dev/null differ
diff --git a/src/bench/runBench.ts b/src/bench/runBench.ts
deleted file mode 100644
index c14ac9a7d2..0000000000
--- a/src/bench/runBench.ts
+++ /dev/null
@@ -1,627 +0,0 @@
-/**
- * Headless export bench — the real pipeline, driven from a command line.
- *
- * Runs inside the app's own editor window (windowType=bench), so it exercises
- * the real preload, the real sandbox, the real GPU and the real main-process
- * ffmpeg. It loads a real saved project and calls exportAxcutDocument, the same
- * entry point ExportDialog uses — nothing about the export path is simulated.
- *
- * Why it exists: driving the export through the UI costs ~5 minutes a run and
- * silently injects confounds (an open DevTools panel handicapped one arm of the
- * first A/B; a window that lost focus stole another). A command gives repeats
- * cheaply, and repeats are what tell drift apart from effect.
- *
- * Deliberately NOT React: the bench replaces the app's UI entirely, so nothing
- * renders alongside the export.
- *
- *   npm run bench:export -- --project=os_parity --arms=webcodecs,native --runs=3
- */
-
-import { exportAxcutDocument } from "@/lib/ai-edition/exporter/documentExporter";
-import { type AxcutDocument, zoomRegionSchema } from "@/lib/ai-edition/schema";
-import type { ExportQuality } from "@/lib/exporter";
-import { nativeBridgeClient } from "@/native/client";
-
-export interface BenchArm {
-	/** localStorage flags applied before the run — the levers under test. */
-	nativeEncode: boolean;
-	readFrequently: boolean;
-	/** Extract every frame and discard it. Diagnostic only — writes no file. */
-	dropFrames?: boolean;
-	/** Composite every frame and stop there. Diagnostic only — writes no file. */
-	compositeOnly?: boolean;
-	/** Undo the 2026-07-17 compositor fixes, to attribute them. */
-	legacyCompositor?: boolean;
-	/** Gate G0: sync the GPU after compositing, in a `fence` stage of its own. */
-	gpuFence?: boolean;
-	/** Diagnostic: shadow path minus the gaussians. Renders no shadow. */
-	shadowNoFilter?: boolean;
-	/** The §8b compositor: one WGSL program. POC — renders no text/cursor/3D. */
-	wgslCompositor?: boolean;
-	/**
-	 * Effects this arm adds to --effects, so an effect can be A/B'd INSIDE one
-	 * interleaved run.
-	 *
-	 * --effects alone cannot answer "what does this effect cost": it is one value
-	 * for the whole session, so the comparison becomes two sessions — and this
-	 * machine drifts further between sessions (up to 62%) than any effect is
-	 * worth. That is the mistake this bench exists to prevent.
-	 */
-	addEffects?: string[];
-}
-
-export interface BenchRunResult {
-	arm: string;
-	run: number;
-	ok: boolean;
-	error?: string;
-	/** The exporter's frame-loop wall — what the arms are compared on. */
-	wallMs: number;
-	/** Everything outside the loop (project load, renderer init), reported not compared. */
-	setupMs?: number;
-	frames: number;
-	fps: number;
-	/** Per-stage totals in ms, keyed as StageTimings names it. */
-	stages: Record<string, number>;
-	/** Shadow cache hits/misses for the run — see BenchArm.addEffects / Step 3. */
-	shadow?: { hits: number; misses: number };
-}
-
-const params = new URLSearchParams(window.location.search);
-
-/** The dialog's labels, so the bench is asked for what the UI shows. */
-const QUALITY: Record<string, ExportQuality> = {
-	"720p": "medium",
-	"1080p": "good",
-	source: "source",
-};
-
-const BENCH_PARAMS = {
-	project: params.get("project"),
-	arms: (params.get("arms") ?? "webcodecs,native").split(",").filter(Boolean),
-	runs: Number(params.get("runs") ?? "2"),
-	fps: Number(params.get("fps") ?? "60"),
-	// "good" is the dialog's own default, i.e. what the UI A/B measured.
-	quality: QUALITY[params.get("quality") ?? "1080p"] ?? "good",
-	effects: (params.get("effects") ?? "").split(",").filter(Boolean),
-	// Cap the timeline to its first N seconds (in memory). Iteration speed:
-	// per-frame stage attribution is a steady-state metric, so ~180 frames say
-	// what 820 say, at a quarter of the wait. Wall/fps from a capped run are NOT
-	// comparable with full-length runs — compare per-frame, or same-cap runs.
-	clip: params.get("clip") ? Number(params.get("clip")) : null,
-	// Discarded runs before the measured ones. The session's FIRST export pays for
-	// shader compilation, decoder setup and JIT, and it lands on whichever arm ran
-	// first: measured at 9.3 s against 5.6/6.6/5.8 s for its own repeats — a 60%
-	// same-arm spread that voided the run all by itself, while the arm that merely
-	// went second looked better. One warm-up costs ~5 s at --clip=4.
-	warmup: Number(params.get("warmup") ?? "1"),
-	// Emit this frame of every arm as a PNG, so the pictures can be compared. The
-	// only thing that says a compositor WORKS; fps says only that it ran.
-	dumpFrame: params.get("dumpFrame"),
-};
-
-/**
- * Appearance the exporter reads out of `legacyEditor`, patched onto an in-memory
- * COPY of the document.
- *
- * Most saved projects carry no appearance at all, so the defaults apply:
- * shadowIntensity 0, showBlur false, borderRadius 0, wallpaper "". Whole effects
- * therefore never execute, and "fixing" them would have measured exactly zero on
- * a project that never ran them. This turns them on without writing to the
- * user's project store — nothing here reaches disk.
- *
- *   --effects=shadow,blur,radius
- */
-const EFFECT_PATCHES: Record<string, Record<string, unknown>> = {
-	// Three chained drop-shadows over the full frame, every frame.
-	shadow: { shadowIntensity: 1 },
-	// A static wallpaper, re-blurred every frame.
-	blur: { showBlur: true },
-	radius: { borderRadius: 24 },
-	motionBlur: { motionBlurAmount: 1 },
-	// Without padding the recording covers the whole stage, so the background, the
-	// rounded corners and the shadow are all computed and then hidden behind it.
-	// The COST is real either way — which is why the timing arms never needed this
-	// — but a parity check has to be able to SEE what it is comparing.
-	padding: { padding: 45 },
-	// Turning an effect OFF is not the same as omitting it: a saved project has
-	// its own appearance (this bench's reference carries shadowIntensity 0.52 and
-	// motionBlurAmount 0.31), so an arm that "doesn't add shadow" still renders
-	// the project's. These patches are what make an arm PAIR isolate one effect.
-	noShadow: { shadowIntensity: 0 },
-	noMotionBlur: { motionBlurAmount: 0 },
-};
-
-/**
- * A zoom region, injected the same way: the saved projects have `zoomRanges: []`.
- *
- * It is not decoration. Zoom is the one effect that changes the composited
- * GEOMETRY every frame, so it is what invalidates any geometry-keyed cache. A
- * parity test on a project without zoom would happily pass with a broken cache
- * key, because nothing would ever ask it to invalidate.
- *
- * Parsed through the real schema before it is injected, because this region was
- * born with `depth: "medium"` — a value nothing accepts. `ZOOM_DEPTH_SCALES`
- * keys on 1..6, so the lookup returned undefined and the zoom silently did
- * NOTHING: the arm reported a clean number for an effect that never ran. The
- * schema is the only thing that knows what the pipeline accepts, so ask it.
- */
-function zoomRanges(doc: AxcutDocument): unknown[] {
-	const clips = (doc as { timeline?: { clips?: { timelineEndSec?: number }[] } }).timeline?.clips;
-	const endSec = clips?.[0]?.timelineEndSec ?? 5;
-	return [
-		zoomRegionSchema.parse({
-			id: "bench-zoom",
-			startMs: 500,
-			endMs: Math.max(1500, Math.round(endSec * 1000) - 500),
-			// 3 is DEFAULT_ZOOM_DEPTH, and what the reference project's own zoom uses.
-			depth: 3,
-			focus: { cx: 0.5, cy: 0.5 },
-			focusMode: "manual",
-		}),
-	];
-}
-
-/**
- * Truncate the timeline to its first N seconds, on the in-memory copy only.
- *
- * Clips are 1:1 with source time in the v4 model (speed is applied later, from
- * legacyEditor.speedRegions, by the export segment loop), so capping timeline
- * and source together keeps the document coherent. Regions past the cap simply
- * never fire, like on any short project. Nothing here reaches disk.
- */
-function withClipCap(doc: AxcutDocument, seconds: number | null): AxcutDocument {
-	if (!seconds || !(seconds > 0)) return doc;
-	const timeline = (
-		doc as {
-			timeline?: {
-				clips?: {
-					sourceStartSec: number;
-					sourceEndSec: number;
-					timelineStartSec: number;
-					timelineEndSec: number;
-				}[];
-			};
-		}
-	).timeline;
-	if (!timeline?.clips?.length) return doc;
-	const clips = [];
-	for (const clip of timeline.clips) {
-		if (clip.timelineStartSec >= seconds) continue;
-		if (clip.timelineEndSec <= seconds) {
-			clips.push(clip);
-			continue;
-		}
-		const keep = seconds - clip.timelineStartSec;
-		clips.push({
-			...clip,
-			timelineEndSec: seconds,
-			sourceEndSec: clip.sourceStartSec + keep,
-		});
-	}
-	if (clips.length === 0) {
-		throw new Error(`--clip=${seconds} leaves no timeline at all`);
-	}
-	return { ...doc, timeline: { ...timeline, clips } } as AxcutDocument;
-}
-
-function withEffects(doc: AxcutDocument, effects: string[]): AxcutDocument {
-	if (effects.length === 0) return doc;
-	const legacy: Record<string, unknown> = {
-		...((doc as { legacyEditor?: Record<string, unknown> }).legacyEditor ?? {}),
-	};
-	let patched = doc;
-	for (const name of effects) {
-		if (name === "zoom") {
-			patched = { ...patched, zoomRanges: zoomRanges(doc) } as AxcutDocument;
-			continue;
-		}
-		const patch = EFFECT_PATCHES[name];
-		if (!patch) {
-			throw new Error(`Unknown effect "${name}". Known: ${Object.keys(EFFECT_PATCHES)}, zoom`);
-		}
-		Object.assign(legacy, patch);
-	}
-	// `blur` only does anything against a real wallpaper; a project with none
-	// would silently skip the very pass being measured.
-	if (effects.includes("blur") && !legacy.wallpaper) {
-		legacy.wallpaper = "wallpaper13.jpg";
-	}
-	return { ...patched, legacyEditor: legacy } as AxcutDocument;
-}
-
-const ARMS: Record<string, BenchArm> = {
-	// The path we ship today: WebCodecs encodes straight off the GPU texture.
-	webcodecs: { nativeEncode: false, readFrequently: false },
-	// Frames descend to the CPU and cross to ffmpeg.
-	native: { nativeEncode: true, readFrequently: false },
-	// Native, but with CPU-backed canvases (what Linux already does) so the
-	// per-frame descent is a memcpy rather than a GPU round-trip.
-	"native-cpu": { nativeEncode: true, readFrequently: true },
-	// Control: isolates the canvas change from the encoder change. Without this
-	// arm a native-cpu win could be the canvas, the encoder, or neither.
-	"webcodecs-cpu": { nativeEncode: false, readFrequently: true },
-	// Ceiling, not a candidate: descend every frame to RAM, then discard it —
-	// the crossing costs exactly zero. Bounds EVERY "remove the crossing"
-	// proposal at once (option A' sandbox:false, shared memory, zero-copy
-	// transfer), because none of them can skip the readback. Writes no file.
-	"readback-ceiling": { nativeEncode: true, readFrequently: false, dropFrames: true },
-	// Prices the GPU compositing of the real effect set, with nothing downstream
-	// to absorb it. This is the number the native-core case rests on: a pipeline
-	// that composites on-device cannot beat decode + this + encode. Writes no file.
-	"composite-ceiling": { nativeEncode: true, readFrequently: false, compositeOnly: true },
-	// The same ceiling with the compositor fixes undone. Pairing these two in one
-	// interleaved run is the only honest way to price the fixes: across sessions
-	// this machine drifts further than they are worth.
-	"composite-ceiling-legacy": {
-		nativeEncode: true,
-		readFrequently: false,
-		compositeOnly: true,
-		legacyCompositor: true,
-	},
-	/** Today's shipping path, with the compositor fixes undone. */
-	"webcodecs-legacy": { nativeEncode: false, readFrequently: false, legacyCompositor: true },
-	// Gate G0 (rendering-architecture.md §7.1): the shipping path, but the GPU is
-	// forced to FINISH compositing before the encode timers start. The claim under
-	// test is pure attribution — encodeWait has been billing the compositor's
-	// execution. If §7.1 holds, encodeWait collapses to the encoder's own time and
-	// the difference reappears under `fence`; the wall itself may even worsen
-	// (the fence removes compositor/encoder overlap), which is fine — G0 is about
-	// where the time GOES, not how much there is. Run interleaved with its
-	// unfenced twin.
-	"webcodecs-fence": { nativeEncode: false, readFrequently: false, gpuFence: true },
-	// Same gate against the PRE-fix compositor — the arm the spec's numbers
-	// (encodeWait ~18.9 → ~6 ms) are actually quoted for.
-	"webcodecs-legacy-fence": {
-		nativeEncode: false,
-		readFrequently: false,
-		legacyCompositor: true,
-		gpuFence: true,
-	},
-	// Step 3 (rendering-architecture.md §13): the missing L7 row. A zoom is the one
-	// effect that moves the composited geometry every frame, so it is what the
-	// shadow cache cannot hold — pair it with `webcodecs-fence` in ONE interleaved
-	// run and the difference is the cost of a moving camera, on one thermal state.
-	// Fenced on both sides so the compositor's cost lands in `fence` on both,
-	// instead of hiding in the encoder's queue on both.
-	"webcodecs-fence-zoom": {
-		nativeEncode: false,
-		readFrequently: false,
-		gpuFence: true,
-		addEffects: ["zoom"],
-	},
-	// The other half of the Step-3 question. A zoom does not only miss the shadow
-	// cache — it also puts the camera in motion, which switches the motion-blur
-	// filter on. Run these two against the pair above and the arithmetic separates
-	// the shadow from everything else the zoom drags in:
-	//   (zoom − zoom-noshadow)  = the shadow with the cache MISSING every frame
-	//   (still − still-noshadow) = the shadow with the cache HOLDING
-	// Without them, "zoom is slower" is true and says nothing about what to fix.
-	"webcodecs-fence-noshadow": {
-		nativeEncode: false,
-		readFrequently: false,
-		gpuFence: true,
-		addEffects: ["noShadow"],
-	},
-	"webcodecs-fence-zoom-noshadow": {
-		nativeEncode: false,
-		readFrequently: false,
-		gpuFence: true,
-		addEffects: ["zoom", "noShadow"],
-	},
-	// Splits the 16.7 ms cache miss in two, which is what decides the SHAPE of the
-	// fix. Against `webcodecs-fence-zoom` it prices the three gaussians; against
-	// `webcodecs-fence-zoom-noshadow` it prices the full-frame plumbing that feeds
-	// them. A shader is the answer to the first; touching less of the frame is the
-	// answer to the second. Renders no shadow — measurement only, never shipped.
-	"webcodecs-fence-zoom-nofilter": {
-		nativeEncode: false,
-		readFrequently: false,
-		gpuFence: true,
-		shadowNoFilter: true,
-		addEffects: ["zoom"],
-	},
-	// The POC (Step 4). Pair each against its Canvas2D twin above — same decode,
-	// same encoder, same document, one interleaved run — and the difference is the
-	// compositor and nothing else. The zoom pair is the one that matters: it is
-	// the case the 2D cache cannot hold and the shader has no cache to miss.
-	wgsl: { nativeEncode: false, readFrequently: false, wgslCompositor: true },
-	// The parity gate, not a speed arm: the native sink WRITES AN MP4, so this pair
-	// produces one file each — same timeline, same encoder, same bitrate, one
-	// compositor apart — and the two pictures can be diffed. The descent to ffmpeg
-	// makes them slow, which does not matter: nobody is timing a correctness check.
-	"wgsl-native-zoom": {
-		nativeEncode: true,
-		readFrequently: false,
-		wgslCompositor: true,
-		addEffects: ["zoom"],
-	},
-	"native-zoom": { nativeEncode: true, readFrequently: false, addEffects: ["zoom"] },
-	"wgsl-fence": {
-		nativeEncode: false,
-		readFrequently: false,
-		gpuFence: true,
-		wgslCompositor: true,
-	},
-	"wgsl-fence-zoom": {
-		nativeEncode: false,
-		readFrequently: false,
-		gpuFence: true,
-		wgslCompositor: true,
-		addEffects: ["zoom"],
-	},
-	// The shader compositor minus the shadow cascade. Against `wgsl-fence` it
-	// prices the cascade — 18 full-frame passes, which is the naive version of an
-	// algorithm whose whole point was that it is cheap on a GPU.
-	"wgsl-fence-noshadow": {
-		nativeEncode: false,
-		readFrequently: false,
-		gpuFence: true,
-		wgslCompositor: true,
-		addEffects: ["noShadow"],
-	},
-	// These two WRITE FILES, which is what makes them the parity gate: encode the
-	// same timeline with the old and new compositor through the same encoder at
-	// the same bitrate, then diff the results (SSIM). Unit tests never look at a
-	// pixel, and "obviously equivalent" is what this investigation keeps punishing.
-	"native-legacy": { nativeEncode: true, readFrequently: false, legacyCompositor: true },
-};
-
-function applyArm(arm: BenchArm): void {
-	localStorage.setItem("openscreen.nativeEncode", arm.nativeEncode ? "1" : "0");
-	localStorage.setItem("openscreen.readFrequently", arm.readFrequently ? "1" : "0");
-	localStorage.setItem("openscreen.dropFrames", arm.dropFrames ? "1" : "0");
-	localStorage.setItem("openscreen.compositeOnly", arm.compositeOnly ? "1" : "0");
-	localStorage.setItem("openscreen.legacyCompositor", arm.legacyCompositor ? "1" : "0");
-	localStorage.setItem("openscreen.gpuFence", arm.gpuFence ? "1" : "0");
-	localStorage.setItem("openscreen.shadowNoFilter", arm.shadowNoFilter ? "1" : "0");
-	localStorage.setItem("openscreen.wgslCompositor", arm.wgslCompositor ? "1" : "0");
-	if (BENCH_PARAMS.dumpFrame) localStorage.setItem("openscreen.dumpFrame", BENCH_PARAMS.dumpFrame);
-	else localStorage.removeItem("openscreen.dumpFrame");
-}
-
-/**
- * aiEdition.get() reports failure as {success:false, error} rather than
- * throwing, so an unchecked read of .document turns every load error into a
- * silent null — which is exactly how "project not found" masked the real reason
- * once already. Surface it.
- */
-async function loadDocument(id: string): Promise<AxcutDocument> {
-	const result = (await nativeBridgeClient.aiEdition.get(id)) as {
-		success?: boolean;
-		document?: AxcutDocument;
-		error?: string;
-	};
-	if (!result?.success || !result.document) {
-		throw new Error(`Cannot load project ${id}: ${result?.error ?? "no document returned"}`);
-	}
-	return result.document;
-}
-
-/**
- * Accepts a project id, an id prefix, or a title.
- *
- * Titles need care: a summary's title is the name the project was CREATED with
- * ("Recording 15/07/2026 18:38:53") and does not follow a rename, so the one
- * shown in the editor — the document's own project.title — may match nothing in
- * the summary list. Hence the fallback that opens documents to check. It is the
- * slow path on purpose: only reached when the cheap matches miss.
- */
-async function resolveDocument(projectRef: string | null): Promise<AxcutDocument> {
-	const projects = await nativeBridgeClient.aiEdition.listProjects();
-	if (projects.length === 0) throw new Error("No saved projects to bench against");
-	if (!projectRef) return loadDocument(projects[0].id);
-
-	const summary =
-		projects.find((p) => p.id === projectRef) ??
-		projects.find((p) => p.id.startsWith(projectRef)) ??
-		projects.find((p) => p.title === projectRef);
-	if (summary) return loadDocument(summary.id);
-
-	const failures: string[] = [];
-	for (const p of projects) {
-		try {
-			const doc = await loadDocument(p.id);
-			if (doc.project?.title === projectRef) return doc;
-		} catch (error) {
-			failures.push(error instanceof Error ? error.message : String(error));
-		}
-	}
-	throw new Error(
-		`Project "${projectRef}" not found by id, id prefix, or title ` +
-			`(${projects.length} searched, ${failures.length} failed to load).` +
-			(failures.length ? `\nFirst load failure: ${failures[0]}` : ""),
-	);
-}
-
-/**
- * Largest source on the timeline — mirrors ExportDialog's referenceSource so
- * "Source" quality picks the same output size the UI would.
- */
-function referenceSource(doc: AxcutDocument): { width?: number; height?: number } {
-	let best: { width?: number; height?: number } = {};
-	let bestArea = 0;
-	for (const asset of doc.assets ?? []) {
-		const w = asset.video?.width;
-		const h = asset.video?.height;
-		if (!w || !h) continue;
-		if (w * h > bestArea) {
-			bestArea = w * h;
-			best = { width: w, height: h };
-		}
-	}
-	return best;
-}
-
-interface Captured {
-	stages: Record<string, number>;
-	/** The exporter's own loop numbers, which exclude the bench's setup. */
-	loop: { wallMs: number; frames: number; fps: number } | null;
-	/** Shadow cache hits/misses — the Step-3 decision input. */
-	shadow: { hits: number; misses: number } | null;
-	restore: () => void;
-}
-
-/** The perf line the exporter prints is for humans; the bench needs the numbers. */
-function captureStages(): Captured {
-	const captured: Captured = {
-		stages: {},
-		loop: null,
-		shadow: null,
-		restore: () => {
-			console.warn = original;
-		},
-	};
-	const original = console.warn;
-	console.warn = (...args: unknown[]) => {
-		const text = args.map(String).join(" ");
-		if (text.includes("[export perf]")) {
-			// "[export perf] wall 77557ms · 546 frames · 7.0 fps"
-			const head = /wall\s+([\d.]+)ms\D+(\d+)\s+frames\D+([\d.]+)\s+fps/.exec(text);
-			if (head) {
-				captured.loop = {
-					wallMs: Number(head[1]),
-					frames: Number(head[2]),
-					fps: Number(head[3]),
-				};
-			}
-			// "[export perf] shadow cache: 100 hits, 20 misses (16.7% miss of 120)"
-			const shadow = /shadow cache:\s*(\d+)\s+hits,\s*(\d+)\s+misses/.exec(text);
-			if (shadow) {
-				captured.shadow = { hits: Number(shadow[1]), misses: Number(shadow[2]) };
-			}
-			for (const line of text.split("\n")) {
-				// "  render     1680.0    3.0%     3.08  n=546"
-				const m = /^\s*([a-zA-Z]+)\s+([\d.]+)\s+[\d.]+%/.exec(line);
-				if (m && m[1] !== "TOTAL") captured.stages[m[1]] = Number(m[2]);
-			}
-		}
-		original(...args);
-	};
-	return captured;
-}
-
-async function runOnce(
-	doc: AxcutDocument,
-	armName: string,
-	arm: BenchArm,
-	run: number,
-): Promise<BenchRunResult> {
-	applyArm(arm);
-	const src = referenceSource(doc);
-	const capture = captureStages();
-	const started = performance.now();
-	try {
-		const result = await exportAxcutDocument(doc, {
-			format: "mp4",
-			quality: BENCH_PARAMS.quality,
-			frameRate: BENCH_PARAMS.fps,
-			codec: "h264",
-			sourceWidth: src.width,
-			sourceHeight: src.height,
-		});
-		const wallMs = performance.now() - started;
-		// The native arm returns no blob (ffmpeg wrote the file itself), so a
-		// missing blob is not a failure here the way it is in ExportDialog.
-		if (!result.success) throw new Error(result.error ?? "export failed");
-		if (!capture.loop) throw new Error("exporter printed no [export perf] line");
-		return {
-			arm: armName,
-			run,
-			ok: true,
-			// The exporter's own loop wall, not the bench's: comparing arms means
-			// comparing the frame loop, not project loading.
-			wallMs: capture.loop.wallMs,
-			setupMs: wallMs - capture.loop.wallMs,
-			frames: capture.loop.frames,
-			fps: capture.loop.fps,
-			stages: capture.stages,
-			shadow: capture.shadow ?? undefined,
-		};
-	} catch (error) {
-		return {
-			arm: armName,
-			run,
-			ok: false,
-			error: error instanceof Error ? error.message : String(error),
-			wallMs: performance.now() - started,
-			frames: 0,
-			fps: 0,
-			stages: capture.stages,
-		};
-	} finally {
-		capture.restore();
-	}
-}
-
-/**
- * Interleaves arms rather than running each arm's repeats together: A,B,A,B.
- * Same-arm repeats then bracket the other arm in time, so drift shows up as
- * disagreement between a run and its own repeat instead of masquerading as the
- * effect under test. The first A/B on this machine drifted 26% between two
- * identical runs — enough to invert the conclusion.
- */
-export async function runBench(): Promise<void> {
-	const results: BenchRunResult[] = [];
-	const emit = (event: string, payload: unknown) =>
-		// Picked up by the runner off stdout; console.warn is what the app's
-		// console forwarder actually relays to the main process.
-		console.warn(`[bench] ${JSON.stringify({ event, ...(payload as object) })}`);
-
-	try {
-		for (const armName of BENCH_PARAMS.arms) {
-			if (!ARMS[armName]) throw new Error(`Unknown arm "${armName}"`);
-		}
-		// Loaded once: the title fallback can open every project on disk, and every
-		// arm must see the same source document.
-		// Cap BEFORE effects, so the injected zoom fits inside the capped window.
-		const base = withClipCap(await resolveDocument(BENCH_PARAMS.project), BENCH_PARAMS.clip);
-		// One document per EFFECT SET, not per arm: arms sharing a set share the
-		// exact object, so they cannot differ by anything but their own flags.
-		const docs = new Map<string, AxcutDocument>();
-		const docFor = (arm: BenchArm): AxcutDocument => {
-			const effects = [...BENCH_PARAMS.effects, ...(arm.addEffects ?? [])];
-			const key = effects.join(",");
-			const existing = docs.get(key);
-			if (existing) return existing;
-			const built = withEffects(base, effects);
-			docs.set(key, built);
-			return built;
-		};
-		emit("start", {
-			arms: BENCH_PARAMS.arms,
-			runs: BENCH_PARAMS.runs,
-			project: base.project?.title ?? "(untitled)",
-			effects: BENCH_PARAMS.effects.length ? BENCH_PARAMS.effects.join("+") : "(project default)",
-			clip: BENCH_PARAMS.clip,
-			warmup: BENCH_PARAMS.warmup,
-		});
-		// Warm up EVERY arm, not just the first: each one's first pass is the one
-		// that pays. Results are dropped on the floor.
-		for (let w = 0; w < BENCH_PARAMS.warmup; w++) {
-			for (const armName of BENCH_PARAMS.arms) {
-				const arm = ARMS[armName];
-				const result = await runOnce(docFor(arm), armName, arm, 0);
-				// A warm-up that FAILS is still a broken arm — say so now rather than
-				// let the measured pass report the same failure four times.
-				if (!result.ok) throw new Error(`warm-up failed for ${armName}: ${result.error}`);
-				emit("warmup", { arm: armName, wallMs: result.wallMs, fps: result.fps });
-			}
-		}
-		for (let run = 1; run <= BENCH_PARAMS.runs; run++) {
-			for (const armName of BENCH_PARAMS.arms) {
-				const arm = ARMS[armName];
-				// The runner needs to know whose frame a dumped PNG is: the exporter
-				// emits it mid-run, before the result that would have named the arm.
-				emit("armStart", { arm: armName, run });
-				const result = await runOnce(docFor(arm), armName, arm, run);
-				results.push(result);
-				emit("run", result);
-			}
-		}
-		emit("done", { results });
-	} catch (error) {
-		emit("fatal", { error: error instanceof Error ? error.message : String(error) });
-	}
-	await window.electronAPI?.benchFinished?.();
-}
diff --git a/src/components/ai-edition/ArrowSvgs.tsx b/src/components/ai-edition/ArrowSvgs.tsx
deleted file mode 100644
index fffbb08a5b..0000000000
--- a/src/components/ai-edition/ArrowSvgs.tsx
+++ /dev/null
@@ -1,212 +0,0 @@
-// Inline SVG arrows for 8 directions (pure paths, not icon fonts, so the native
-// compositor replicates them identically — cf. `arrow_segments_viewbox` in regions.rs,
-// which carries the same numbers and is pinned to them by a test).
-//
-// Les barbes des quatre DIAGONALES ont été refaites pour égaler les cardinales sur les DEUX
-// paramètres qui font une pointe de flèche : la longueur (21,2 unités de viewBox, contre 15,8
-// à l'origine) ET l'ouverture. C'est l'angle qui trahissait le plus : les cardinales ouvrent à
-// ±45° du fût, les diagonales à ±25° seulement, donnant un crochet étroit qui se fondait dans
-// le fût dès que le trait épaississait. Les barbes sont désormais dérivées de la direction du
-// fût par rotation de ±45°, la même règle qui produit exactement les (35,35)/(65,35) des
-// cardinales — la géométrie est donc uniforme par construction, pas par retouche.
-
-import type { AxcutAnnotationRegion } from "@/lib/ai-edition/schema";
-
-type ArrowDirection = NonNullable<AxcutAnnotationRegion["figureData"]>["arrowDirection"];
-
-interface ArrowSvgProps {
-	color: string;
-	strokeWidth: number;
-	className?: string;
-}
-
-export function ArrowUp({ color, strokeWidth, className }: ArrowSvgProps) {
-	return (
-		<svg viewBox="0 0 100 100" className={className} style={{ width: "100%", height: "100%" }}>
-			<defs>
-				<filter id="arrow-shadow">
-					<feDropShadow dx="0" dy="2" stdDeviation="4" floodOpacity="0.3" />
-				</filter>
-			</defs>
-			<path
-				d="M 50 20 L 50 80 M 50 20 L 35 35 M 50 20 L 65 35"
-				stroke={color}
-				strokeWidth={strokeWidth}
-				strokeLinecap="round"
-				strokeLinejoin="round"
-				fill="none"
-				filter="url(#arrow-shadow)"
-			/>
-		</svg>
-	);
-}
-
-export function ArrowDown({ color, strokeWidth, className }: ArrowSvgProps) {
-	return (
-		<svg viewBox="0 0 100 100" className={className} style={{ width: "100%", height: "100%" }}>
-			<defs>
-				<filter id="arrow-shadow">
-					<feDropShadow dx="0" dy="2" stdDeviation="4" floodOpacity="0.3" />
-				</filter>
-			</defs>
-			<path
-				d="M 50 20 L 50 80 M 50 80 L 35 65 M 50 80 L 65 65"
-				stroke={color}
-				strokeWidth={strokeWidth}
-				strokeLinecap="round"
-				strokeLinejoin="round"
-				fill="none"
-				filter="url(#arrow-shadow)"
-			/>
-		</svg>
-	);
-}
-
-export function ArrowLeft({ color, strokeWidth, className }: ArrowSvgProps) {
-	return (
-		<svg viewBox="0 0 100 100" className={className} style={{ width: "100%", height: "100%" }}>
-			<defs>
-				<filter id="arrow-shadow">
-					<feDropShadow dx="0" dy="2" stdDeviation="4" floodOpacity="0.3" />
-				</filter>
-			</defs>
-			<path
-				d="M 80 50 L 20 50 M 20 50 L 35 35 M 20 50 L 35 65"
-				stroke={color}
-				strokeWidth={strokeWidth}
-				strokeLinecap="round"
-				strokeLinejoin="round"
-				fill="none"
-				filter="url(#arrow-shadow)"
-			/>
-		</svg>
-	);
-}
-
-export function ArrowRight({ color, strokeWidth, className }: ArrowSvgProps) {
-	return (
-		<svg viewBox="0 0 100 100" className={className} style={{ width: "100%", height: "100%" }}>
-			<defs>
-				<filter id="arrow-shadow">
-					<feDropShadow dx="0" dy="2" stdDeviation="4" floodOpacity="0.3" />
-				</filter>
-			</defs>
-			<path
-				d="M 20 50 L 80 50 M 80 50 L 65 35 M 80 50 L 65 65"
-				stroke={color}
-				strokeWidth={strokeWidth}
-				strokeLinecap="round"
-				strokeLinejoin="round"
-				fill="none"
-				filter="url(#arrow-shadow)"
-			/>
-		</svg>
-	);
-}
-
-export function ArrowUpRight({ color, strokeWidth, className }: ArrowSvgProps) {
-	return (
-		<svg viewBox="0 0 100 100" className={className} style={{ width: "100%", height: "100%" }}>
-			<defs>
-				<filter id="arrow-shadow">
-					<feDropShadow dx="0" dy="2" stdDeviation="4" floodOpacity="0.3" />
-				</filter>
-			</defs>
-			<path
-				d="M 25 75 L 75 25 M 75 25 L 53.8 25 M 75 25 L 75 46.2"
-				stroke={color}
-				strokeWidth={strokeWidth}
-				strokeLinecap="round"
-				strokeLinejoin="round"
-				fill="none"
-				filter="url(#arrow-shadow)"
-			/>
-		</svg>
-	);
-}
-
-export function ArrowUpLeft({ color, strokeWidth, className }: ArrowSvgProps) {
-	return (
-		<svg viewBox="0 0 100 100" className={className} style={{ width: "100%", height: "100%" }}>
-			<defs>
-				<filter id="arrow-shadow">
-					<feDropShadow dx="0" dy="2" stdDeviation="4" floodOpacity="0.3" />
-				</filter>
-			</defs>
-			<path
-				d="M 75 75 L 25 25 M 25 25 L 25 46.2 M 25 25 L 46.2 25"
-				stroke={color}
-				strokeWidth={strokeWidth}
-				strokeLinecap="round"
-				strokeLinejoin="round"
-				fill="none"
-				filter="url(#arrow-shadow)"
-			/>
-		</svg>
-	);
-}
-
-export function ArrowDownRight({ color, strokeWidth, className }: ArrowSvgProps) {
-	return (
-		<svg viewBox="0 0 100 100" className={className} style={{ width: "100%", height: "100%" }}>
-			<defs>
-				<filter id="arrow-shadow">
-					<feDropShadow dx="0" dy="2" stdDeviation="4" floodOpacity="0.3" />
-				</filter>
-			</defs>
-			<path
-				d="M 25 25 L 75 75 M 75 75 L 75 53.8 M 75 75 L 53.8 75"
-				stroke={color}
-				strokeWidth={strokeWidth}
-				strokeLinecap="round"
-				strokeLinejoin="round"
-				fill="none"
-				filter="url(#arrow-shadow)"
-			/>
-		</svg>
-	);
-}
-
-export function ArrowDownLeft({ color, strokeWidth, className }: ArrowSvgProps) {
-	return (
-		<svg viewBox="0 0 100 100" className={className} style={{ width: "100%", height: "100%" }}>
-			<defs>
-				<filter id="arrow-shadow">
-					<feDropShadow dx="0" dy="2" stdDeviation="4" floodOpacity="0.3" />
-				</filter>
-			</defs>
-			<path
-				d="M 75 25 L 25 75 M 25 75 L 46.2 75 M 25 75 L 25 53.8"
-				stroke={color}
-				strokeWidth={strokeWidth}
-				strokeLinecap="round"
-				strokeLinejoin="round"
-				fill="none"
-				filter="url(#arrow-shadow)"
-			/>
-		</svg>
-	);
-}
-
-export function getArrowComponent(direction: ArrowDirection) {
-	switch (direction) {
-		case "up":
-			return ArrowUp;
-		case "down":
-			return ArrowDown;
-		case "left":
-			return ArrowLeft;
-		case "right":
-			return ArrowRight;
-		case "up-right":
-			return ArrowUpRight;
-		case "up-left":
-			return ArrowUpLeft;
-		case "down-right":
-			return ArrowDownRight;
-		case "down-left":
-			return ArrowDownLeft;
-		default:
-			return ArrowRight;
-	}
-}
diff --git a/src/components/ai-edition/ExportDialog.tsx b/src/components/ai-edition/ExportDialog.tsx
index a0256c1391..eab9493052 100644
--- a/src/components/ai-edition/ExportDialog.tsx
+++ b/src/components/ai-edition/ExportDialog.tsx
@@ -36,7 +36,7 @@ import {
 	type GifSizePreset,
 } from "@/lib/exporter";
 import { calculateMp4ExportSettings } from "@/lib/exporter/mp4ExportSettings";
-import { exportMultiNative, exportNative } from "@/native";
+import { exportMultiNative } from "@/native";
 import { nativeBridgeClient } from "@/native/client";
 import type { CompositorClipInput } from "@/native/contracts";
 import { buildSceneDescription, resolveVisibleClips } from "@/native/sceneDescription";
@@ -284,15 +284,15 @@ export function ExportDialog({ open, onClose, document }: ExportDialogProps) {
 			try {
 				const sceneJson = JSON.stringify(buildSceneDescription(document));
 				const outDims = tierOutputDims(quality);
-				const stats =
-					clips.length > 0
-						? await exportMultiNative(clips, pickedPath, sceneJson, {
-								width: outDims?.width,
-								height: outDims?.height,
-								fps,
-								codec,
-							})
-						: await exportNative(pickedPath);
+				if (clips.length === 0) {
+					throw new Error(t("exportDialog.nothingToExport"));
+				}
+				const stats = await exportMultiNative(clips, pickedPath, sceneJson, {
+					width: outDims?.width,
+					height: outDims?.height,
+					fps,
+					codec,
+				});
 				setSavedPath(pickedPath);
 				setPhase("done");
 				toast.success(t("exportDialog.exportedVideo"), {
diff --git a/src/components/ai-edition/preview-compositor/PreviewCompositor.module.css b/src/components/ai-edition/preview-compositor/PreviewCompositor.module.css
deleted file mode 100644
index a1b3ade40d..0000000000
--- a/src/components/ai-edition/preview-compositor/PreviewCompositor.module.css
+++ /dev/null
@@ -1,56 +0,0 @@
-.container {
-	display: flex;
-	flex-direction: column;
-	gap: 0.5rem;
-	width: 100%;
-	height: 100%;
-	align-items: center;
-	justify-content: center;
-}
-
-.videoFrame {
-	position: relative;
-	width: 100%;
-	height: 100%;
-	display: flex;
-	align-items: center;
-	justify-content: center;
-}
-
-/* Decode source only — never painted. Kept in normal flow (not display:none)
-   so its intrinsic-ratio contain-fit box is real and CursorPreviewLayer's
-   ResizeObserver (which measures a `<video>` sibling) keeps working
-   unmodified. The composited pixels come from the canvas below. */
-.video {
-	visibility: hidden;
-	max-width: 100%;
-	max-height: 100%;
-}
-
-/* Positioned/sized in JS to exactly match the hidden video's rendered rect
-   (see the rect-sync effect in PreviewCompositor.tsx) — same technique
-   CursorPreviewLayer already uses for its own overlay. */
-.canvasHost {
-	position: absolute;
-	pointer-events: none;
-	overflow: hidden;
-}
-
-.overlay {
-	position: absolute;
-	display: flex;
-	align-items: center;
-	justify-content: center;
-	color: var(--muted-foreground);
-	font-size: 0.875rem;
-	background: var(--card);
-	padding: 0.75rem 1.25rem;
-	border-radius: 0.5rem;
-}
-
-.placeholder {
-	color: var(--muted-foreground);
-	font-size: 0.875rem;
-	text-align: center;
-	padding: 2rem;
-}
diff --git a/src/components/ai-edition/preview-compositor/PreviewCompositor.tsx b/src/components/ai-edition/preview-compositor/PreviewCompositor.tsx
deleted file mode 100644
index 02c787d237..0000000000
--- a/src/components/ai-edition/preview-compositor/PreviewCompositor.tsx
+++ /dev/null
@@ -1,499 +0,0 @@
-// Single-canvas Pixi/WebGL compositor for the screen recording, replacing
-// the CSS-transform + plain <video> approach `VirtualPreview` used.
-//
-// Why: the screen recording used to be a bare <video> element with zoom/pan
-// applied as a CSS `transform` on its wrapper div, re-computed on every
-// virtual-time tick. That's a DOM style write + layout/paint cost 60x/sec on
-// top of the browser's own video decode/paint — main branch instead decodes
-// the video straight into a Pixi texture and applies zoom/pan as a Pixi
-// container transform, so the whole frame (video + mask + zoom) is one GPU
-// draw call per tick with no DOM reflow. This component ports that approach
-// for the screen source only (the webcam stays a plain <video> — see
-// WebcamOverlay.tsx and playback-clock.ts for its own, separately-fixed,
-// sync story; main doesn't Pixi-composite the webcam either).
-//
-// The actual timeline-aware playback logic (clip-boundary advancement, skip
-// ranges, speed regions, asset switching, seeking) is unchanged from
-// VirtualPreview — only the RENDERING of the active frame moved from
-// CSS+<video> to Pixi+<canvas>. The <video> element itself is kept in the
-// DOM (invisible) purely as the decode source Pixi's VideoSource wraps, and
-// so CursorPreviewLayer's existing "measure the sibling <video>" sizing
-// keeps working unmodified.
-
-import { Application, Container, Graphics, Sprite, Texture, VideoSource } from "pixi.js";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { fromFileUrl } from "@/components/video-editor/projectPersistence";
-import { MAX_NATIVE_PLAYBACK_RATE } from "@/components/video-editor/types";
-import { resolvePlaybackSegments } from "@/lib/ai-edition/document/timeline";
-import type { AxcutClip, AxcutTrimRange, AxcutZoomRegion } from "@/lib/ai-edition/schema";
-import { useEditorSettings } from "@/lib/ai-edition/store/useEditorSettings";
-import type { PlaybackClockRef } from "@/lib/ai-edition/timeline/playback-clock";
-import { findActiveSpeedRegion, type SpeedRegion } from "@/lib/ai-edition/timeline/speed";
-import {
-	clampVirtualTime,
-	findNextKeptSegment,
-	getRawVirtualStartTime,
-	locateSourcePosition,
-	locateVirtualPosition,
-	totalVirtualDuration,
-} from "@/lib/ai-edition/timeline/virtual-preview";
-import {
-	computeZoomPreviewTransform,
-	IDENTITY_ZOOM_TRANSFORM,
-} from "@/lib/ai-edition/timeline/zoom-preview";
-import { CursorPreviewLayer } from "../CursorPreviewLayer";
-import styles from "./PreviewCompositor.module.css";
-
-export interface VideoSourceDescriptor {
-	id: string;
-	src: string;
-	label: string;
-}
-
-interface PreviewCompositorProps {
-	videoSources: VideoSourceDescriptor[];
-	clips: AxcutClip[];
-	zoomRegions?: AxcutZoomRegion[];
-	speedRegions?: SpeedRegion[];
-	trimRanges?: AxcutTrimRange[];
-	seekTarget?: { timeSec: number; isSource?: boolean; requestId: number } | null;
-	onTimeChange?: (timeSec: number) => void;
-	onLoadedMetadata?: (durationSec: number, assetId: string) => void;
-	onVideoElement?: (element: HTMLVideoElement | null) => void;
-	onVideoError?: () => void;
-	/** Written every tick so the webcam overlay can stay locked to this clock. */
-	clockRef?: PlaybackClockRef;
-}
-
-interface Size {
-	width: number;
-	height: number;
-}
-
-export function PreviewCompositor({
-	videoSources,
-	clips,
-	zoomRegions = [],
-	speedRegions = [],
-	trimRanges = [],
-	seekTarget,
-	onTimeChange,
-	onLoadedMetadata,
-	onVideoElement,
-	onVideoError,
-	clockRef,
-}: PreviewCompositorProps) {
-	const { settings } = useEditorSettings();
-	const videoRef = useRef<HTMLVideoElement | null>(null);
-	const frameRef = useRef<HTMLDivElement | null>(null);
-	const canvasHostRef = useRef<HTMLDivElement | null>(null);
-
-	const isProgrammaticSeekRef = useRef(false);
-	const pendingSeekRef = useRef<{ sourceTimeSec: number; play: boolean } | null>(null);
-	const [virtualTimeSec, setVirtualTimeSec] = useState(0);
-	const [isPlaying, setIsPlaying] = useState(false);
-	const [loadState, setLoadState] = useState<"idle" | "loading" | "ready" | "error">("idle");
-	const [sourceIndex, setSourceIndex] = useState(0);
-	const [canvasSize, setCanvasSize] = useState<Size>({ width: 0, height: 0 });
-
-	const virtualDurationSec = useMemo(() => totalVirtualDuration(clips), [clips]);
-	const activeSource = videoSources[sourceIndex] ?? null;
-
-	// See VirtualPreview's original comment: the cursor overlay wants
-	// source-media time, not virtual-timeline time.
-	const [sourceTimeSec, setSourceTimeSec] = useState(0);
-
-	const sourceTimeSecRef = useRef(0);
-	sourceTimeSecRef.current = sourceTimeSec;
-	const clipsRef = useRef(clips);
-	clipsRef.current = clips;
-	const videoSourcesRef = useRef(videoSources);
-	videoSourcesRef.current = videoSources;
-	const sourceIndexRef = useRef(sourceIndex);
-	sourceIndexRef.current = sourceIndex;
-	const virtualTimeSecRef = useRef(virtualTimeSec);
-	virtualTimeSecRef.current = virtualTimeSec;
-	const virtualDurationSecRef = useRef(virtualDurationSec);
-	virtualDurationSecRef.current = virtualDurationSec;
-	const speedRegionsRef = useRef(speedRegions);
-	speedRegionsRef.current = speedRegions;
-	const trimRangesRef = useRef(trimRanges);
-	trimRangesRef.current = trimRanges;
-	const playbackClips = useMemo(
-		() => resolvePlaybackSegments(clips, trimRanges),
-		[clips, trimRanges],
-	);
-	const playbackClipsRef = useRef(playbackClips);
-	playbackClipsRef.current = playbackClips;
-
-	const updateVirtualTime = useCallback(
-		(nextTimeSec: number) => {
-			setVirtualTimeSec(nextTimeSec);
-			onTimeChange?.(nextTimeSec);
-			const v = videoRef.current;
-			if (v) {
-				const activeRegion = findActiveSpeedRegion(
-					speedRegionsRef.current,
-					Math.round(nextTimeSec * 1000),
-				);
-				// Chromium hard-caps HTMLMediaElement.playbackRate at 16×; above that the
-				// element can't actually play faster and the shared clock (below) would
-				// desync from the real frame advance. Clamp the live preview to the native
-				// ceiling — the export path renders the true speed offline (WSOLA audio +
-				// offline frame retiming, gated on MAX_NATIVE_PLAYBACK_RATE).
-				const rate = Math.min(activeRegion?.speed ?? 1, MAX_NATIVE_PLAYBACK_RATE);
-				if (v.playbackRate !== rate) v.playbackRate = rate;
-			}
-		},
-		[onTimeChange],
-	);
-
-	// Playback/time-mapping rAF — ported verbatim from VirtualPreview, plus
-	// publishing this frame's state to the shared clock for the webcam.
-	// biome-ignore lint/correctness/useExhaustiveDependencies: re-create when the active source swaps.
-	useEffect(() => {
-		let raf = 0;
-		const tick = () => {
-			raf = window.requestAnimationFrame(tick);
-			const v = videoRef.current;
-			if (!v || !Number.isFinite(v.currentTime)) {
-				return;
-			}
-			if (clockRef) {
-				clockRef.current.sourceTimeSec = v.currentTime;
-				clockRef.current.isPlaying = !v.paused;
-				clockRef.current.playbackRate = v.playbackRate;
-				clockRef.current.virtualTimeSec = virtualTimeSecRef.current;
-			}
-			const activeSourceId = videoSourcesRef.current[sourceIndexRef.current]?.id;
-			if (!v.paused) {
-				const inKeptSegment = locateSourcePosition(
-					playbackClipsRef.current,
-					v.currentTime,
-					activeSourceId,
-				);
-				if (!inKeptSegment) {
-					const nextKeptSegment = findNextKeptSegment(
-						playbackClipsRef.current,
-						clipsRef.current,
-						virtualTimeSecRef.current,
-						activeSourceId,
-						v.currentTime,
-					);
-					if (nextKeptSegment) {
-						const rawTargetTime = getRawVirtualStartTime(nextKeptSegment, clipsRef.current);
-						seekToVirtualTime(rawTargetTime, true);
-						return;
-					}
-					v.pause();
-					updateVirtualTime(virtualDurationSecRef.current);
-					setIsPlaying(false);
-					return;
-				}
-			}
-			if (v.readyState >= 2) {
-				setSourceTimeSec(v.currentTime);
-			}
-			if (clipsRef.current.length === 0) {
-				updateVirtualTime(v.currentTime);
-				return;
-			}
-			if (isProgrammaticSeekRef.current) {
-				isProgrammaticSeekRef.current = false;
-				const pos = locateSourcePosition(clipsRef.current, v.currentTime, activeSourceId);
-				if (pos) updateVirtualTime(clampVirtualTime(clipsRef.current, pos.virtualTimeSec));
-				return;
-			}
-			const position = locateSourcePosition(clipsRef.current, v.currentTime, activeSourceId);
-			if (!position) {
-				const nextClip = clipsRef.current.find(
-					(clip) => clip.timelineStartSec > virtualTimeSecRef.current + 0.001,
-				);
-				if (nextClip) seekToVirtualTime(nextClip.timelineStartSec, true);
-				else {
-					v.pause();
-					updateVirtualTime(virtualDurationSecRef.current);
-					setIsPlaying(false);
-				}
-				return;
-			}
-			const reachedClipEnd = v.currentTime >= (position.clip.sourceEndSec ?? Infinity) - 0.04;
-			if (reachedClipEnd) {
-				const nextClip = clipsRef.current[position.clipIndex + 1];
-				if (!nextClip) {
-					v.pause();
-					updateVirtualTime(virtualDurationSecRef.current);
-					setIsPlaying(false);
-					return;
-				}
-				seekToVirtualTime(nextClip.timelineStartSec, true);
-				return;
-			}
-			updateVirtualTime(clampVirtualTime(clipsRef.current, position.virtualTimeSec));
-		};
-		raf = window.requestAnimationFrame(tick);
-		return () => window.cancelAnimationFrame(raf);
-	}, [activeSource?.src]);
-
-	const activeSourceKey = activeSource?.src ?? null;
-	// biome-ignore lint/correctness/useExhaustiveDependencies: re-run on source swap
-	useEffect(() => {
-		onVideoElement?.(videoRef.current);
-		return () => onVideoElement?.(null);
-	}, [onVideoElement, activeSourceKey]);
-
-	const seekToVirtualTime = useCallback(
-		(nextVirtualTimeSec: number, preservePlayback = false) => {
-			const position = locateVirtualPosition(clips, nextVirtualTimeSec);
-			if (!position) {
-				updateVirtualTime(0);
-				setIsPlaying(false);
-				return;
-			}
-			const targetIndex = videoSources.findIndex((vs) => vs.id === position.clip.assetId);
-			const isAssetSwitch = targetIndex >= 0 && targetIndex !== sourceIndex;
-			const shouldContinuePlayback = preservePlayback && isPlaying;
-
-			if (isAssetSwitch) {
-				setSourceIndex(targetIndex);
-				setLoadState("loading");
-				updateVirtualTime(position.virtualTimeSec);
-				pendingSeekRef.current = {
-					sourceTimeSec: position.sourceTimeSec,
-					play: shouldContinuePlayback,
-				};
-				return;
-			}
-
-			const video = videoRef.current;
-			if (!video) return;
-
-			isProgrammaticSeekRef.current = true;
-			updateVirtualTime(position.virtualTimeSec);
-			if (Math.abs(video.currentTime - position.sourceTimeSec) > 0.01) {
-				video.currentTime = position.sourceTimeSec;
-			}
-			if (shouldContinuePlayback) {
-				void video.play().catch(() => setIsPlaying(false));
-			}
-		},
-		[clips, videoSources, sourceIndex, isPlaying, updateVirtualTime],
-	);
-
-	const seekToSourceTime = useCallback((sourceTimeSec: number) => {
-		const video = videoRef.current;
-		if (!video) return;
-		isProgrammaticSeekRef.current = true;
-		if (Math.abs(video.currentTime - sourceTimeSec) > 0.01) {
-			video.currentTime = sourceTimeSec;
-		}
-	}, []);
-
-	useEffect(() => {
-		if (!seekTarget) return;
-		if (seekTarget.isSource) {
-			seekToSourceTime(seekTarget.timeSec);
-		} else {
-			seekToVirtualTime(seekTarget.timeSec);
-		}
-	}, [seekTarget, seekToVirtualTime, seekToSourceTime]);
-
-	// --- Pixi compositor -----------------------------------------------
-
-	const appRef = useRef<Application | null>(null);
-	const spriteRef = useRef<Sprite | null>(null);
-	const maskRef = useRef<Graphics | null>(null);
-	const cameraContainerRef = useRef<Container | null>(null);
-	const [pixiReady, setPixiReady] = useState(false);
-
-	// Keep the canvas host positioned/sized exactly over the hidden video's
-	// rendered (contain-fit) box — same rect-tracking technique
-	// CursorPreviewLayer already uses for its own overlay.
-	// biome-ignore lint/correctness/useExhaustiveDependencies: re-run on source swap so the observer re-attaches
-	useEffect(() => {
-		const video = videoRef.current;
-		const frame = frameRef.current;
-		const host = canvasHostRef.current;
-		if (!video || !frame || !host) return;
-		const update = () => {
-			const videoRect = video.getBoundingClientRect();
-			const frameRect = frame.getBoundingClientRect();
-			if (videoRect.width <= 0 || videoRect.height <= 0) return;
-			const width = Math.round(videoRect.width);
-			const height = Math.round(videoRect.height);
-			host.style.left = `${Math.round(videoRect.left - frameRect.left)}px`;
-			host.style.top = `${Math.round(videoRect.top - frameRect.top)}px`;
-			host.style.width = `${width}px`;
-			host.style.height = `${height}px`;
-			setCanvasSize((prev) =>
-				prev.width === width && prev.height === height ? prev : { width, height },
-			);
-		};
-		update();
-		const ro = new ResizeObserver(update);
-		ro.observe(video);
-		ro.observe(frame);
-		return () => ro.disconnect();
-	}, [activeSourceKey]);
-
-	// Create the Pixi Application + video sprite once per active source.
-	// biome-ignore lint/correctness/useExhaustiveDependencies: re-create when the active source swaps
-	useEffect(() => {
-		const video = videoRef.current;
-		const host = canvasHostRef.current;
-		if (!video || !host || !activeSource) return;
-		let mounted = true;
-		let app: Application | null = null;
-
-		(async () => {
-			app = new Application();
-			await app.init({
-				width: canvasSize.width || 1,
-				height: canvasSize.height || 1,
-				backgroundAlpha: 0,
-				antialias: true,
-				resolution: window.devicePixelRatio || 1,
-				autoDensity: true,
-			});
-			if (!mounted) {
-				app.destroy(true, { children: true, texture: true, textureSource: true });
-				return;
-			}
-			app.ticker.maxFPS = 60;
-			host.appendChild(app.canvas);
-			appRef.current = app;
-
-			const source = VideoSource.from(video);
-			(source as unknown as { autoPlay: boolean }).autoPlay = false;
-			(source as unknown as { autoUpdate: boolean }).autoUpdate = true;
-			const texture = Texture.from(source);
-			const sprite = new Sprite(texture);
-			const mask = new Graphics();
-			const cameraContainer = new Container();
-			cameraContainer.addChild(sprite);
-			cameraContainer.mask = mask;
-			app.stage.addChild(mask, cameraContainer);
-
-			spriteRef.current = sprite;
-			maskRef.current = mask;
-			cameraContainerRef.current = cameraContainer;
-			setPixiReady(true);
-		})();
-
-		return () => {
-			mounted = false;
-			setPixiReady(false);
-			if (app?.renderer) {
-				const canvas = app.canvas;
-				if (canvas.parentElement === host) host.removeChild(canvas);
-				app.destroy(true, { children: true, texture: true, textureSource: true });
-			}
-			appRef.current = null;
-			spriteRef.current = null;
-			maskRef.current = null;
-			cameraContainerRef.current = null;
-		};
-	}, [activeSourceKey]);
-
-	// Resize the renderer + redraw the rounded-corner mask whenever the
-	// measured box or the border-radius setting changes.
-	useEffect(() => {
-		if (!pixiReady) return;
-		const app = appRef.current;
-		const mask = maskRef.current;
-		const sprite = spriteRef.current;
-		if (!app || !mask || !sprite) return;
-		const { width, height } = canvasSize;
-		if (width <= 0 || height <= 0) return;
-		app.renderer.resize(width, height);
-		sprite.width = width;
-		sprite.height = height;
-		mask.clear();
-		mask.roundRect(0, 0, width, height, settings.borderRadius).fill({ color: 0xffffff });
-	}, [pixiReady, canvasSize, settings.borderRadius]);
-
-	// Zoom/pan: same easing math as before (computeZoomPreviewTransform),
-	// applied as a Pixi container transform instead of a CSS `transform`
-	// string. Pixi composes scale-then-position around origin (0,0) by
-	// default, matching CSS's `translate() scale()` composition order with
-	// `transform-origin: 0 0` — so the percentage-based translate output
-	// maps directly onto pixel offsets of the (pre-scale) canvas size.
-	useEffect(() => {
-		if (!pixiReady) return;
-		const cameraContainer = cameraContainerRef.current;
-		if (!cameraContainer) return;
-		const activeSpeedRegion = findActiveSpeedRegion(
-			speedRegionsRef.current,
-			Math.round(virtualTimeSec * 1000),
-		);
-		const playbackRate = activeSpeedRegion?.speed ?? 1;
-		const transform =
-			zoomRegions.length === 0
-				? IDENTITY_ZOOM_TRANSFORM
-				: computeZoomPreviewTransform(zoomRegions, virtualTimeSec * 1000, undefined, playbackRate);
-		cameraContainer.scale.set(transform.scale);
-		cameraContainer.position.set(
-			(transform.translateXPercent / 100) * canvasSize.width,
-			(transform.translateYPercent / 100) * canvasSize.height,
-		);
-	}, [pixiReady, zoomRegions, virtualTimeSec, canvasSize]);
-
-	return (
-		<div className={styles.container}>
-			{activeSource ? (
-				<div
-					ref={frameRef}
-					className={styles.videoFrame}
-					style={{ cursor: settings.cursorShow ? "none" : undefined }}
-				>
-					<video
-						key={activeSource.src}
-						ref={videoRef}
-						src={activeSource.src}
-						className={styles.video}
-						preload="metadata"
-						playsInline
-						onLoadedMetadata={(e) => {
-							setLoadState("ready");
-							onLoadedMetadata?.(e.currentTarget.duration, activeSource.id);
-							if (pendingSeekRef.current) {
-								const { sourceTimeSec, play } = pendingSeekRef.current;
-								pendingSeekRef.current = null;
-								e.currentTarget.currentTime = sourceTimeSec;
-								if (play) {
-									void e.currentTarget.play().catch(() => setIsPlaying(false));
-								}
-							} else if (clips.length > 0) {
-								seekToVirtualTime(virtualTimeSec);
-							}
-						}}
-						onWaiting={() => setLoadState("loading")}
-						onCanPlay={() => setLoadState("ready")}
-						onError={() => {
-							pendingSeekRef.current = null;
-							setLoadState("error");
-							setIsPlaying(false);
-							onVideoError?.();
-						}}
-						onPause={() => setIsPlaying(false)}
-						onPlay={() => setIsPlaying(true)}
-						onEnded={() => setIsPlaying(false)}
-					/>
-					<div ref={canvasHostRef} className={styles.canvasHost} />
-					{loadState !== "ready" && (
-						<div className={styles.overlay}>
-							{loadState === "error" ? "Video preview could not be loaded." : "Loading preview…"}
-						</div>
-					)}
-					<CursorPreviewLayer
-						videoPath={activeSource ? fromFileUrl(activeSource.src) : null}
-						currentTimeSec={sourceTimeSec}
-						isPlaying={isPlaying}
-					/>
-				</div>
-			) : (
-				<div className={styles.placeholder}>Attach a video to start previewing.</div>
-			)}
-		</div>
-	);
-}
diff --git a/src/components/ui/accordion.tsx b/src/components/ui/accordion.tsx
deleted file mode 100644
index 22456b252b..0000000000
--- a/src/components/ui/accordion.tsx
+++ /dev/null
@@ -1,55 +0,0 @@
-import * as AccordionPrimitive from "@radix-ui/react-accordion";
-import { ChevronDown } from "lucide-react";
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-
-const Accordion = AccordionPrimitive.Root;
-
-const AccordionItem = React.forwardRef<
-	React.ElementRef<typeof AccordionPrimitive.Item>,
-	React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Item>
->(({ className, ...props }, ref) => (
-	<AccordionPrimitive.Item
-		ref={ref}
-		className={cn("border-b border-white/5", className)}
-		{...props}
-	/>
-));
-AccordionItem.displayName = "AccordionItem";
-
-const AccordionTrigger = React.forwardRef<
-	React.ElementRef<typeof AccordionPrimitive.Trigger>,
-	React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger>
->(({ className, children, ...props }, ref) => (
-	<AccordionPrimitive.Header className="flex">
-		<AccordionPrimitive.Trigger
-			ref={ref}
-			className={cn(
-				"flex flex-1 items-center justify-between py-3 text-sm font-medium text-slate-200 transition-all hover:text-white [&[data-state=open]>svg]:rotate-180",
-				className,
-			)}
-			{...props}
-		>
-			{children}
-			<ChevronDown className="h-4 w-4 shrink-0 text-slate-400 transition-transform duration-200" />
-		</AccordionPrimitive.Trigger>
-	</AccordionPrimitive.Header>
-));
-AccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName;
-
-const AccordionContent = React.forwardRef<
-	React.ElementRef<typeof AccordionPrimitive.Content>,
-	React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Content>
->(({ className, children, ...props }, ref) => (
-	<AccordionPrimitive.Content
-		ref={ref}
-		className="overflow-hidden text-sm data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down"
-		{...props}
-	>
-		<div className={cn("pb-4 pt-0", className)}>{children}</div>
-	</AccordionPrimitive.Content>
-));
-AccordionContent.displayName = AccordionPrimitive.Content.displayName;
-
-export { Accordion, AccordionContent, AccordionItem, AccordionTrigger };
diff --git a/src/components/ui/card.tsx b/src/components/ui/card.tsx
deleted file mode 100644
index 048076444c..0000000000
--- a/src/components/ui/card.tsx
+++ /dev/null
@@ -1,55 +0,0 @@
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-
-const Card = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
-	({ className, ...props }, ref) => (
-		<div
-			ref={ref}
-			className={cn("rounded-xl border bg-card text-card-foreground shadow", className)}
-			{...props}
-		/>
-	),
-);
-Card.displayName = "Card";
-
-const CardHeader = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
-	({ className, ...props }, ref) => (
-		<div ref={ref} className={cn("flex flex-col space-y-1.5 p-6", className)} {...props} />
-	),
-);
-CardHeader.displayName = "CardHeader";
-
-const CardTitle = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
-	({ className, ...props }, ref) => (
-		<div
-			ref={ref}
-			className={cn("font-semibold leading-none tracking-tight", className)}
-			{...props}
-		/>
-	),
-);
-CardTitle.displayName = "CardTitle";
-
-const CardDescription = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
-	({ className, ...props }, ref) => (
-		<div ref={ref} className={cn("text-sm text-muted-foreground", className)} {...props} />
-	),
-);
-CardDescription.displayName = "CardDescription";
-
-const CardContent = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
-	({ className, ...props }, ref) => (
-		<div ref={ref} className={cn("p-6 pt-0", className)} {...props} />
-	),
-);
-CardContent.displayName = "CardContent";
-
-const CardFooter = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
-	({ className, ...props }, ref) => (
-		<div ref={ref} className={cn("flex items-center p-6 pt-0", className)} {...props} />
-	),
-);
-CardFooter.displayName = "CardFooter";
-
-export { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle };
diff --git a/src/components/ui/color-picker.tsx b/src/components/ui/color-picker.tsx
deleted file mode 100644
index 72f0135e25..0000000000
--- a/src/components/ui/color-picker.tsx
+++ /dev/null
@@ -1,159 +0,0 @@
-import { HsvaColor, hexToHsva } from "@uiw/color-convert";
-import Block from "@uiw/react-color-block";
-import Colorful from "@uiw/react-color-colorful";
-import { useEffect, useState } from "react";
-import { Button } from "./button";
-import { Input } from "./input";
-
-type BaseProps = {
-	selectedColor: string;
-	colorPalette: string[];
-	onUpdateColor: (color: string) => void;
-};
-
-type ColorPickerProps =
-	| (BaseProps & {
-			clearBackgroundOption?: false;
-			translations: Record<"colorWheel" | "colorPalette", string>;
-	  })
-	| (BaseProps & {
-			clearBackgroundOption: true;
-			translations: Record<"colorWheel" | "colorPalette" | "clearBackground", string>;
-	  });
-
-export default function ColorPicker(props: ColorPickerProps) {
-	const { selectedColor, colorPalette, translations, onUpdateColor } = props;
-	const [colorMode, setColorMode] = useState<"wheel" | "palette">("wheel");
-	const [hexInput, setHexInput] = useState(selectedColor);
-	const [transparentColorHSVA, setTransparentColorHSVA] = useState<HsvaColor>({
-		h: 0,
-		s: 0,
-		v: 0,
-		a: 0,
-	});
-
-	useEffect(() => {
-		setHexInput(selectedColor);
-	}, [selectedColor]);
-
-	const getTextColor = (color: string) => {
-		if (color === "transparent") return "#ffffff";
-		const r = parseInt(color.slice(1, 3), 16);
-		const g = parseInt(color.slice(3, 5), 16);
-		const b = parseInt(color.slice(5, 7), 16);
-		const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
-		if (luminance > 186) return "#000000";
-		return "#ffffff";
-	};
-
-	// Prefix a # when the user typed a bare hex value.
-	const normalizeHexDraft = (raw: string) => {
-		const trimmed = raw.trim();
-		if (trimmed === "") return "";
-		if (/^[0-9A-Fa-f]/.test(trimmed[0])) return `#${trimmed}`;
-		return trimmed;
-	};
-
-	const handleColorInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
-		const normalized = normalizeHexDraft(e.target.value);
-		setHexInput(normalized);
-		// Only push when it's a complete #RGB or #RRGGBB value.
-		const isValidHexColor =
-			/^#[0-9A-Fa-f]{3}$/.test(normalized) || /^#[0-9A-Fa-f]{6}$/.test(normalized);
-		if (isValidHexColor) {
-			onUpdateColor(normalized);
-		}
-	};
-
-	const toTransparent = (color: string) => {
-		if (color === "transparent") return;
-		const hsva = hexToHsva(color);
-		hsva.a = 0;
-		return hsva;
-	};
-	return (
-		<div className="p-1 flex flex-col gap-4 items-center">
-			<div className="flex items-center gap-2 w-full">
-				<Button
-					variant="outline"
-					size="sm"
-					className="w-full h-9 justify-start gap-2 bg-white/5 border-white/10 hover:bg-white/10 px-2"
-					onClick={() => setColorMode("wheel")}
-					style={{
-						backgroundColor: colorMode === "wheel" ? "#34B27B" : "transparent",
-					}}
-				>
-					<span className="text-xs text-slate-300 truncate flex-1 text-left">
-						{translations.colorWheel}
-					</span>
-				</Button>
-				<Button
-					variant="outline"
-					size="sm"
-					className="w-full h-9 justify-start gap-2 bg-white/5 border-white/10 hover:bg-white/10 px-2"
-					onClick={() => setColorMode("palette")}
-					style={{
-						backgroundColor: colorMode === "palette" ? "#34B27B" : "transparent",
-					}}
-				>
-					<span className="text-xs text-slate-300 truncate flex-1 text-left">
-						{translations.colorPalette}
-					</span>
-				</Button>
-			</div>
-			{colorMode === "wheel" && (
-				<>
-					<div
-						className={`w-full h-20 flex items-center justify-center border border-white/10 rounded-lg`}
-						style={{ backgroundColor: selectedColor }}
-					>
-						<span style={{ color: getTextColor(selectedColor) }}>{selectedColor}</span>
-					</div>
-					<Colorful
-						color={selectedColor !== "transparent" ? selectedColor : transparentColorHSVA}
-						onChange={(color) => {
-							onUpdateColor(color.hex);
-						}}
-						style={{
-							borderRadius: "8px",
-						}}
-						disableAlpha={true}
-					/>
-					<Input
-						type="text"
-						value={hexInput}
-						className="w-full h-9 rounded-md border border-white/10 bg-white/5 px-2 text-xs text-slate-200 outline-none focus:border-[#34B27B]/50 focus:ring-1 focus:ring-[#34B27B]/30 [appearance:textfield] [&::-webkit-outer-spin-button]:appearance-none [&::-webkit-inner-spin-button]:appearance-none"
-						onChange={handleColorInputChange}
-					/>
-				</>
-			)}
-			{colorMode === "palette" && (
-				<Block
-					color={selectedColor !== "transparent" ? selectedColor : transparentColorHSVA}
-					colors={colorPalette}
-					onChange={(color) => {
-						onUpdateColor(color.hex);
-					}}
-					style={{
-						width: "100%",
-						borderRadius: "8px",
-					}}
-				/>
-			)}
-			{props.clearBackgroundOption === true && (
-				<Button
-					variant="ghost"
-					size="sm"
-					className="w-full mt-2 text-xs h-7 hover:bg-white/5 text-slate-400"
-					onClick={() => {
-						const hsva = toTransparent(selectedColor);
-						if (hsva) setTransparentColorHSVA(hsva);
-						onUpdateColor("transparent");
-					}}
-				>
-					{props.translations.clearBackground}
-				</Button>
-			)}
-		</div>
-	);
-}
diff --git a/src/components/ui/content-clamp.tsx b/src/components/ui/content-clamp.tsx
deleted file mode 100644
index c0600c19f5..0000000000
--- a/src/components/ui/content-clamp.tsx
+++ /dev/null
@@ -1,81 +0,0 @@
-"use client";
-
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-import { Popover, PopoverArrow, PopoverContent, PopoverTrigger } from "./popover";
-
-interface ContentClampProps extends React.HTMLAttributes<HTMLDivElement> {
-	children: React.ReactNode;
-	truncateLength?: number;
-}
-
-function ContentClamp({ children, className, truncateLength = 50, ...props }: ContentClampProps) {
-	const text = typeof children === "string" ? children : String(children ?? "");
-	const isTruncated = text.length > truncateLength;
-
-	const [open, setOpen] = React.useState(false);
-	const timeoutRef = React.useRef<NodeJS.Timeout | null>(null);
-
-	const handleMouseEnter = () => {
-		if (timeoutRef.current) {
-			clearTimeout(timeoutRef.current);
-			timeoutRef.current = null;
-		}
-		setOpen(true);
-	};
-
-	const handleMouseLeave = () => {
-		timeoutRef.current = setTimeout(() => {
-			setOpen(false);
-		}, 100);
-	};
-
-	React.useEffect(() => {
-		return () => {
-			if (timeoutRef.current) {
-				clearTimeout(timeoutRef.current);
-			}
-		};
-	}, []);
-
-	if (!isTruncated) {
-		return (
-			<div className={cn("inline", className)} {...props}>
-				{children}
-			</div>
-		);
-	}
-
-	const truncatedText = text.slice(0, truncateLength) + "...";
-
-	return (
-		<Popover open={open} onOpenChange={setOpen}>
-			<PopoverTrigger asChild>
-				<span
-					className={className}
-					onMouseEnter={handleMouseEnter}
-					onMouseLeave={handleMouseLeave}
-					onClick={(e) => e.preventDefault()}
-					{...props}
-				>
-					{truncatedText}
-				</span>
-			</PopoverTrigger>
-			<PopoverContent
-				className="w-auto max-w-sm rounded-lg border border-white bg-popover p-3 text-sm text-popover-foreground"
-				sideOffset={8}
-				animated={false}
-				onMouseEnter={handleMouseEnter}
-				onMouseLeave={handleMouseLeave}
-				onPointerDownOutside={(e) => e.preventDefault()}
-				onClick={(e) => e.stopPropagation()}
-			>
-				<PopoverArrow className="fill-white" />
-				{children}
-			</PopoverContent>
-		</Popover>
-	);
-}
-
-export { ContentClamp };
diff --git a/src/components/ui/dropdown-menu.tsx b/src/components/ui/dropdown-menu.tsx
deleted file mode 100644
index eb140b9714..0000000000
--- a/src/components/ui/dropdown-menu.tsx
+++ /dev/null
@@ -1,194 +0,0 @@
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
-import { Check, ChevronRight, Circle } from "lucide-react";
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-
-const DropdownMenu = DropdownMenuPrimitive.Root;
-
-const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger;
-
-const DropdownMenuGroup = DropdownMenuPrimitive.Group;
-
-const DropdownMenuPortal = DropdownMenuPrimitive.Portal;
-
-const DropdownMenuSub = DropdownMenuPrimitive.Sub;
-
-const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup;
-
-const DropdownMenuSubTrigger = React.forwardRef<
-	React.ElementRef<typeof DropdownMenuPrimitive.SubTrigger>,
-	React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubTrigger> & {
-		inset?: boolean;
-	}
->(({ className, inset, children, ...props }, ref) => (
-	<DropdownMenuPrimitive.SubTrigger
-		ref={ref}
-		className={cn(
-			"flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
-			inset && "pl-8",
-			className,
-		)}
-		{...props}
-	>
-		{children}
-		<ChevronRight className="ml-auto" />
-	</DropdownMenuPrimitive.SubTrigger>
-));
-DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive.SubTrigger.displayName;
-
-const DropdownMenuSubContent = React.forwardRef<
-	React.ElementRef<typeof DropdownMenuPrimitive.SubContent>,
-	React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubContent>
->(({ className, ...props }, ref) => (
-	<DropdownMenuPrimitive.SubContent
-		ref={ref}
-		className={cn(
-			"z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-dropdown-menu-content-transform-origin]",
-			className,
-		)}
-		{...props}
-	/>
-));
-DropdownMenuSubContent.displayName = DropdownMenuPrimitive.SubContent.displayName;
-
-const DropdownMenuContent = React.forwardRef<
-	React.ElementRef<typeof DropdownMenuPrimitive.Content>,
-	React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content> & {
-		portalled?: boolean;
-	}
->(({ className, sideOffset = 4, portalled = true, ...props }, ref) => {
-	const content = (
-		<DropdownMenuPrimitive.Content
-			ref={ref}
-			sideOffset={sideOffset}
-			className={cn(
-				"z-50 max-h-[var(--radix-dropdown-menu-content-available-height)] min-w-[8rem] overflow-y-auto overflow-x-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md",
-				"data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-dropdown-menu-content-transform-origin]",
-				className,
-			)}
-			{...props}
-		/>
-	);
-
-	if (!portalled) {
-		return content;
-	}
-
-	return <DropdownMenuPrimitive.Portal>{content}</DropdownMenuPrimitive.Portal>;
-});
-DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
-
-const DropdownMenuItem = React.forwardRef<
-	React.ElementRef<typeof DropdownMenuPrimitive.Item>,
-	React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & {
-		inset?: boolean;
-	}
->(({ className, inset, ...props }, ref) => (
-	<DropdownMenuPrimitive.Item
-		ref={ref}
-		className={cn(
-			"relative flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&>svg]:size-4 [&>svg]:shrink-0",
-			inset && "pl-8",
-			className,
-		)}
-		{...props}
-	/>
-));
-DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
-
-const DropdownMenuCheckboxItem = React.forwardRef<
-	React.ElementRef<typeof DropdownMenuPrimitive.CheckboxItem>,
-	React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem>
->(({ className, children, checked, ...props }, ref) => (
-	<DropdownMenuPrimitive.CheckboxItem
-		ref={ref}
-		className={cn(
-			"relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
-			className,
-		)}
-		checked={checked}
-		{...props}
-	>
-		<span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
-			<DropdownMenuPrimitive.ItemIndicator>
-				<Check className="h-4 w-4" />
-			</DropdownMenuPrimitive.ItemIndicator>
-		</span>
-		{children}
-	</DropdownMenuPrimitive.CheckboxItem>
-));
-DropdownMenuCheckboxItem.displayName = DropdownMenuPrimitive.CheckboxItem.displayName;
-
-const DropdownMenuRadioItem = React.forwardRef<
-	React.ElementRef<typeof DropdownMenuPrimitive.RadioItem>,
-	React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.RadioItem>
->(({ className, children, ...props }, ref) => (
-	<DropdownMenuPrimitive.RadioItem
-		ref={ref}
-		className={cn(
-			"relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
-			className,
-		)}
-		{...props}
-	>
-		<span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
-			<DropdownMenuPrimitive.ItemIndicator>
-				<Circle className="h-2 w-2 fill-current" />
-			</DropdownMenuPrimitive.ItemIndicator>
-		</span>
-		{children}
-	</DropdownMenuPrimitive.RadioItem>
-));
-DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName;
-
-const DropdownMenuLabel = React.forwardRef<
-	React.ElementRef<typeof DropdownMenuPrimitive.Label>,
-	React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> & {
-		inset?: boolean;
-	}
->(({ className, inset, ...props }, ref) => (
-	<DropdownMenuPrimitive.Label
-		ref={ref}
-		className={cn("px-2 py-1.5 text-sm font-semibold", inset && "pl-8", className)}
-		{...props}
-	/>
-));
-DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName;
-
-const DropdownMenuSeparator = React.forwardRef<
-	React.ElementRef<typeof DropdownMenuPrimitive.Separator>,
-	React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Separator>
->(({ className, ...props }, ref) => (
-	<DropdownMenuPrimitive.Separator
-		ref={ref}
-		className={cn("-mx-1 my-1 h-px bg-muted", className)}
-		{...props}
-	/>
-));
-DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
-
-const DropdownMenuShortcut = ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>) => {
-	return (
-		<span className={cn("ml-auto text-xs tracking-widest opacity-60", className)} {...props} />
-	);
-};
-DropdownMenuShortcut.displayName = "DropdownMenuShortcut";
-
-export {
-	DropdownMenu,
-	DropdownMenuCheckboxItem,
-	DropdownMenuContent,
-	DropdownMenuGroup,
-	DropdownMenuItem,
-	DropdownMenuLabel,
-	DropdownMenuPortal,
-	DropdownMenuRadioGroup,
-	DropdownMenuRadioItem,
-	DropdownMenuSeparator,
-	DropdownMenuShortcut,
-	DropdownMenuSub,
-	DropdownMenuSubContent,
-	DropdownMenuSubTrigger,
-	DropdownMenuTrigger,
-};
diff --git a/src/components/ui/input.tsx b/src/components/ui/input.tsx
deleted file mode 100644
index 68ac869eed..0000000000
--- a/src/components/ui/input.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import * as React from "react";
-import { cn } from "@/lib/utils";
-
-export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {}
-
-const Input = React.forwardRef<HTMLInputElement, InputProps>(
-	({ className, type, ...props }, ref) => {
-		return (
-			<input
-				type={type}
-				className={cn(
-					"flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
-					className,
-				)}
-				ref={ref}
-				{...props}
-			/>
-		);
-	},
-);
-Input.displayName = "Input";
-
-export { Input };
diff --git a/src/components/ui/item-content.tsx b/src/components/ui/item-content.tsx
deleted file mode 100644
index b87d4f5415..0000000000
--- a/src/components/ui/item-content.tsx
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { PropsWithChildren } from "react";
-
-interface ItemContentProps extends PropsWithChildren {
-	classes: string;
-}
-
-function ItemContent({ children, classes }: ItemContentProps) {
-	return (
-		<div
-			className={`bg-white/5 border border-white/10 rounded-md shadow-sm w-full flex flex-row items-center px-3 py-1 gap-2 transition-all duration-150 hover:bg-[#34B27B]/10 hover:shadow-lg ${classes}`}
-			style={{ minHeight: 40 }}
-		>
-			{children}
-		</div>
-	);
-}
-
-export default ItemContent;
diff --git a/src/components/ui/label.tsx b/src/components/ui/label.tsx
deleted file mode 100644
index fd6cbcc8b1..0000000000
--- a/src/components/ui/label.tsx
+++ /dev/null
@@ -1,20 +0,0 @@
-import * as React from "react";
-import { cn } from "@/lib/utils";
-
-export interface LabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {}
-
-const Label = React.forwardRef<HTMLLabelElement, LabelProps>(({ className, ...props }, ref) => {
-	return (
-		<label
-			ref={ref}
-			className={cn(
-				"text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70",
-				className,
-			)}
-			{...props}
-		/>
-	);
-});
-Label.displayName = "Label";
-
-export { Label };
diff --git a/src/components/ui/select.tsx b/src/components/ui/select.tsx
deleted file mode 100644
index bdbf64e9ae..0000000000
--- a/src/components/ui/select.tsx
+++ /dev/null
@@ -1,170 +0,0 @@
-"use client";
-
-import * as SelectPrimitive from "@radix-ui/react-select";
-import { Check, ChevronDown, ChevronUp } from "lucide-react";
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-
-const Select = SelectPrimitive.Root;
-
-const SelectGroup = SelectPrimitive.Group;
-
-const SelectValue = SelectPrimitive.Value;
-
-const SelectTrigger = React.forwardRef<
-	React.ElementRef<typeof SelectPrimitive.Trigger>,
-	React.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger>
->(({ className, children, ...props }, ref) => (
-	<SelectPrimitive.Trigger
-		ref={ref}
-		className={cn(
-			"flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1",
-			className,
-		)}
-		{...props}
-	>
-		{children}
-		<SelectPrimitive.Icon asChild>
-			<ChevronDown className="h-4 w-4 opacity-50" />
-		</SelectPrimitive.Icon>
-	</SelectPrimitive.Trigger>
-));
-SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
-
-const SelectScrollUpButton = React.forwardRef<
-	React.ElementRef<typeof SelectPrimitive.ScrollUpButton>,
-	React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollUpButton>
->(({ className, ...props }, ref) => (
-	<SelectPrimitive.ScrollUpButton
-		ref={ref}
-		className={cn("flex cursor-default items-center justify-center py-1", className)}
-		{...props}
-	>
-		<ChevronUp className="h-4 w-4" />
-	</SelectPrimitive.ScrollUpButton>
-));
-SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName;
-
-const SelectScrollDownButton = React.forwardRef<
-	React.ElementRef<typeof SelectPrimitive.ScrollDownButton>,
-	React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollDownButton>
->(({ className, ...props }, ref) => (
-	<SelectPrimitive.ScrollDownButton
-		ref={ref}
-		className={cn("flex cursor-default items-center justify-center py-1", className)}
-		{...props}
-	>
-		<ChevronDown className="h-4 w-4" />
-	</SelectPrimitive.ScrollDownButton>
-));
-SelectScrollDownButton.displayName = SelectPrimitive.ScrollDownButton.displayName;
-
-const SelectContent = React.forwardRef<
-	React.ElementRef<typeof SelectPrimitive.Content>,
-	React.ComponentPropsWithoutRef<typeof SelectPrimitive.Content> & {
-		showScrollButtons?: boolean;
-		viewportClassName?: string;
-	}
->(
-	(
-		{
-			className,
-			children,
-			position = "popper",
-			showScrollButtons = true,
-			viewportClassName,
-			...props
-		},
-		ref,
-	) => (
-		<SelectPrimitive.Portal>
-			<SelectPrimitive.Content
-				ref={ref}
-				className={cn(
-					/* Above Dialog (z-[10000]) and fullscreen overlays (e.g. z-[99999]) */
-					"relative z-[100000] max-h-96 min-w-[8rem] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
-					position === "popper" &&
-						"data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1",
-					className,
-				)}
-				position={position}
-				{...props}
-			>
-				{showScrollButtons ? <SelectScrollUpButton /> : null}
-				<SelectPrimitive.Viewport
-					className={cn(
-						"p-1",
-						position === "popper" &&
-							"max-h-[var(--radix-select-content-available-height)] w-full min-w-[var(--radix-select-trigger-width)]",
-						viewportClassName,
-					)}
-				>
-					{children}
-				</SelectPrimitive.Viewport>
-				{showScrollButtons ? <SelectScrollDownButton /> : null}
-			</SelectPrimitive.Content>
-		</SelectPrimitive.Portal>
-	),
-);
-SelectContent.displayName = SelectPrimitive.Content.displayName;
-
-const SelectLabel = React.forwardRef<
-	React.ElementRef<typeof SelectPrimitive.Label>,
-	React.ComponentPropsWithoutRef<typeof SelectPrimitive.Label>
->(({ className, ...props }, ref) => (
-	<SelectPrimitive.Label
-		ref={ref}
-		className={cn("py-1.5 pl-8 pr-2 text-sm font-semibold", className)}
-		{...props}
-	/>
-));
-SelectLabel.displayName = SelectPrimitive.Label.displayName;
-
-const SelectItem = React.forwardRef<
-	React.ElementRef<typeof SelectPrimitive.Item>,
-	React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item>
->(({ className, children, ...props }, ref) => (
-	<SelectPrimitive.Item
-		ref={ref}
-		className={cn(
-			"relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
-			className,
-		)}
-		{...props}
-	>
-		<span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
-			<SelectPrimitive.ItemIndicator>
-				<Check className="h-4 w-4" />
-			</SelectPrimitive.ItemIndicator>
-		</span>
-
-		<SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
-	</SelectPrimitive.Item>
-));
-SelectItem.displayName = SelectPrimitive.Item.displayName;
-
-const SelectSeparator = React.forwardRef<
-	React.ElementRef<typeof SelectPrimitive.Separator>,
-	React.ComponentPropsWithoutRef<typeof SelectPrimitive.Separator>
->(({ className, ...props }, ref) => (
-	<SelectPrimitive.Separator
-		ref={ref}
-		className={cn("-mx-1 my-1 h-px bg-muted", className)}
-		{...props}
-	/>
-));
-SelectSeparator.displayName = SelectPrimitive.Separator.displayName;
-
-export {
-	Select,
-	SelectContent,
-	SelectGroup,
-	SelectItem,
-	SelectLabel,
-	SelectScrollDownButton,
-	SelectScrollUpButton,
-	SelectSeparator,
-	SelectTrigger,
-	SelectValue,
-};
diff --git a/src/components/ui/slider.tsx b/src/components/ui/slider.tsx
deleted file mode 100644
index deae89abf5..0000000000
--- a/src/components/ui/slider.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import * as SliderPrimitive from "@radix-ui/react-slider";
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-
-const Slider = React.forwardRef<
-	React.ElementRef<typeof SliderPrimitive.Root>,
-	React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root>
->(({ className, ...props }, ref) => (
-	<SliderPrimitive.Root
-		ref={ref}
-		className={cn("relative flex w-full touch-none select-none items-center", className)}
-		{...props}
-	>
-		<SliderPrimitive.Track className="relative h-1.5 w-full grow overflow-hidden rounded-full bg-white/10">
-			<SliderPrimitive.Range className="absolute h-full bg-[#34B27B]" />
-		</SliderPrimitive.Track>
-		<SliderPrimitive.Thumb className="block h-4 w-4 rounded-full border-2 border-[#34B27B] bg-[#34B27B] shadow transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[#34B27B]/50 disabled:pointer-events-none disabled:opacity-50" />
-	</SliderPrimitive.Root>
-));
-Slider.displayName = SliderPrimitive.Root.displayName;
-
-export { Slider };
diff --git a/src/components/ui/switch.tsx b/src/components/ui/switch.tsx
deleted file mode 100644
index 860339fc94..0000000000
--- a/src/components/ui/switch.tsx
+++ /dev/null
@@ -1,30 +0,0 @@
-import * as SwitchPrimitives from "@radix-ui/react-switch";
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-
-const Switch = React.forwardRef<
-	React.ElementRef<typeof SwitchPrimitives.Root>,
-	React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root>
->(({ className, ...props }, ref) => (
-	<SwitchPrimitives.Root
-		className={cn(
-			"peer inline-flex h-5 w-9 shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent shadow-sm transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50",
-			"data-[state=checked]:bg-[#34B27B] data-[state=unchecked]:bg-[#52525b]",
-			className,
-		)}
-		{...props}
-		ref={ref}
-	>
-		<SwitchPrimitives.Thumb
-			className={cn(
-				"pointer-events-none block h-4 w-4 rounded-full shadow-lg ring-0 transition-transform",
-				"bg-white",
-				"data-[state=checked]:translate-x-4 data-[state=unchecked]:translate-x-0",
-			)}
-		/>
-	</SwitchPrimitives.Root>
-));
-Switch.displayName = SwitchPrimitives.Root.displayName;
-
-export { Switch };
diff --git a/src/components/ui/toggle-group.tsx b/src/components/ui/toggle-group.tsx
deleted file mode 100644
index a887a06ce8..0000000000
--- a/src/components/ui/toggle-group.tsx
+++ /dev/null
@@ -1,56 +0,0 @@
-"use client";
-
-import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
-import { type VariantProps } from "class-variance-authority";
-import * as React from "react";
-import { toggleVariants } from "@/components/ui/toggle";
-import { cn } from "@/lib/utils";
-
-const ToggleGroupContext = React.createContext<VariantProps<typeof toggleVariants>>({
-	size: "default",
-	variant: "default",
-});
-
-const ToggleGroup = React.forwardRef<
-	React.ElementRef<typeof ToggleGroupPrimitive.Root>,
-	React.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Root> &
-		VariantProps<typeof toggleVariants>
->(({ className, variant, size, children, ...props }, ref) => (
-	<ToggleGroupPrimitive.Root
-		ref={ref}
-		className={cn("flex items-center justify-center gap-1", className)}
-		{...props}
-	>
-		<ToggleGroupContext.Provider value={{ variant, size }}>{children}</ToggleGroupContext.Provider>
-	</ToggleGroupPrimitive.Root>
-));
-
-ToggleGroup.displayName = ToggleGroupPrimitive.Root.displayName;
-
-const ToggleGroupItem = React.forwardRef<
-	React.ElementRef<typeof ToggleGroupPrimitive.Item>,
-	React.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Item> &
-		VariantProps<typeof toggleVariants>
->(({ className, children, variant, size, ...props }, ref) => {
-	const context = React.useContext(ToggleGroupContext);
-
-	return (
-		<ToggleGroupPrimitive.Item
-			ref={ref}
-			className={cn(
-				toggleVariants({
-					variant: context.variant || variant,
-					size: context.size || size,
-				}),
-				className,
-			)}
-			{...props}
-		>
-			{children}
-		</ToggleGroupPrimitive.Item>
-	);
-});
-
-ToggleGroupItem.displayName = ToggleGroupPrimitive.Item.displayName;
-
-export { ToggleGroup, ToggleGroupItem };
diff --git a/src/components/ui/toggle.tsx b/src/components/ui/toggle.tsx
deleted file mode 100644
index 4fd784086f..0000000000
--- a/src/components/ui/toggle.tsx
+++ /dev/null
@@ -1,43 +0,0 @@
-"use client";
-
-import * as TogglePrimitive from "@radix-ui/react-toggle";
-import { cva, type VariantProps } from "class-variance-authority";
-import * as React from "react";
-
-import { cn } from "@/lib/utils";
-
-const toggleVariants = cva(
-	"inline-flex items-center justify-center rounded-md text-sm font-medium ring-offset-background transition-colors hover:bg-muted hover:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground",
-	{
-		variants: {
-			variant: {
-				default: "bg-transparent",
-				outline: "border border-input bg-transparent hover:bg-accent hover:text-accent-foreground",
-			},
-			size: {
-				default: "h-10 px-3",
-				sm: "h-9 px-2.5",
-				lg: "h-11 px-5",
-			},
-		},
-		defaultVariants: {
-			variant: "default",
-			size: "default",
-		},
-	},
-);
-
-const Toggle = React.forwardRef<
-	React.ElementRef<typeof TogglePrimitive.Root>,
-	React.ComponentPropsWithoutRef<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>
->(({ className, variant, size, ...props }, ref) => (
-	<TogglePrimitive.Root
-		ref={ref}
-		className={cn(toggleVariants({ variant, size, className }))}
-		{...props}
-	/>
-));
-
-Toggle.displayName = TogglePrimitive.Root.displayName;
-
-export { Toggle, toggleVariants };
diff --git a/src/components/video-editor/EditorMenuBar.test.tsx b/src/components/video-editor/EditorMenuBar.test.tsx
deleted file mode 100644
index 5011985a24..0000000000
--- a/src/components/video-editor/EditorMenuBar.test.tsx
+++ /dev/null
@@ -1,176 +0,0 @@
-import "@testing-library/jest-dom";
-import { cleanup, render, screen } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
-import {
-	buildEditorMenuModel,
-	EditorMenuBar,
-	type EditorMenuBarProps,
-	formatShiftShortcut,
-	formatShortcut,
-} from "./EditorMenuBar";
-
-const LABELS: Record<string, string> = {
-	"common.actions.file": "File",
-	"common.actions.edit": "Edit",
-	"common.actions.view": "View",
-	"common.actions.quit": "Quit",
-	"common.actions.undo": "Undo",
-	"common.actions.redo": "Redo",
-	"common.actions.reload": "Reload",
-	"dialogs.unsavedChanges.newProject": "New Project",
-	"dialogs.unsavedChanges.loadProject": "Load Project…",
-	"dialogs.unsavedChanges.saveProject": "Save Project…",
-	"dialogs.unsavedChanges.saveProjectAs": "Save Project As…",
-};
-
-function makeProps(overrides: Partial<EditorMenuBarProps> = {}): EditorMenuBarProps {
-	return {
-		isMac: false,
-		t: (key: string) => LABELS[key] ?? key,
-		onNewProject: vi.fn(),
-		onLoadProject: vi.fn(),
-		onSaveProject: vi.fn(),
-		onSaveProjectAs: vi.fn(),
-		onQuit: vi.fn(),
-		onUndo: vi.fn(),
-		onRedo: vi.fn(),
-		onReload: vi.fn(),
-		canUndo: true,
-		canRedo: true,
-		...overrides,
-	};
-}
-
-afterEach(() => {
-	cleanup();
-	vi.clearAllMocks();
-});
-
-describe("formatShortcut", () => {
-	it("uses Ctrl on non-mac and the ⌘ symbol on mac", () => {
-		expect(formatShortcut(false, "N")).toBe("Ctrl+N");
-		expect(formatShortcut(true, "N")).toBe("⌘N");
-	});
-
-	it("formats shift combos per platform", () => {
-		expect(formatShiftShortcut(false, "S")).toBe("Ctrl+Shift+S");
-		expect(formatShiftShortcut(true, "S")).toBe("⌘⇧S");
-	});
-});
-
-describe("buildEditorMenuModel", () => {
-	it("returns the File, Edit and View menus with translated labels", () => {
-		const model = buildEditorMenuModel(makeProps());
-		expect(model.map((m) => m.id)).toEqual(["file", "edit", "view"]);
-		expect(model.map((m) => m.label)).toEqual(["File", "Edit", "View"]);
-	});
-
-	it("wires each File item to its handler", () => {
-		const props = makeProps();
-		const [file] = buildEditorMenuModel(props);
-		const byId = Object.fromEntries(file.items.map((i) => [i.id, i]));
-
-		byId["new-project"].onSelect();
-		byId["load-project"].onSelect();
-		byId["save-project"].onSelect();
-		byId["save-project-as"].onSelect();
-		byId.quit.onSelect();
-
-		expect(props.onNewProject).toHaveBeenCalledOnce();
-		expect(props.onLoadProject).toHaveBeenCalledOnce();
-		expect(props.onSaveProject).toHaveBeenCalledOnce();
-		expect(props.onSaveProjectAs).toHaveBeenCalledOnce();
-		expect(props.onQuit).toHaveBeenCalledOnce();
-	});
-
-	it("marks Quit as a destructive item after a separator", () => {
-		const [file] = buildEditorMenuModel(makeProps());
-		const quit = file.items.find((i) => i.id === "quit");
-		expect(quit).toMatchObject({ danger: true, separatorBefore: true });
-	});
-
-	it("shows Ctrl-based shortcut hints on non-mac", () => {
-		const model = buildEditorMenuModel(makeProps({ isMac: false }));
-		const shortcuts = Object.fromEntries(
-			model.flatMap((m) => m.items).map((i) => [i.id, i.shortcut]),
-		);
-		expect(shortcuts).toMatchObject({
-			"new-project": "Ctrl+N",
-			"load-project": "Ctrl+O",
-			"save-project": "Ctrl+S",
-			"save-project-as": "Ctrl+Shift+S",
-			quit: "Ctrl+Q",
-			undo: "Ctrl+Z",
-			redo: "Ctrl+Y",
-			reload: "Ctrl+R",
-		});
-	});
-
-	it("shows ⌘-based shortcut hints on mac (redo uses ⌘⇧Z)", () => {
-		const model = buildEditorMenuModel(makeProps({ isMac: true }));
-		const shortcuts = Object.fromEntries(
-			model.flatMap((m) => m.items).map((i) => [i.id, i.shortcut]),
-		);
-		expect(shortcuts).toMatchObject({
-			"new-project": "⌘N",
-			"save-project-as": "⌘⇧S",
-			undo: "⌘Z",
-			redo: "⌘⇧Z",
-			reload: "⌘R",
-		});
-	});
-
-	it("disables Undo/Redo according to canUndo/canRedo", () => {
-		const model = buildEditorMenuModel(makeProps({ canUndo: false, canRedo: false }));
-		const edit = model.find((m) => m.id === "edit");
-		expect(edit?.items.find((i) => i.id === "undo")?.disabled).toBe(true);
-		expect(edit?.items.find((i) => i.id === "redo")?.disabled).toBe(true);
-
-		const enabled = buildEditorMenuModel(makeProps({ canUndo: true, canRedo: true }));
-		const editEnabled = enabled.find((m) => m.id === "edit");
-		expect(editEnabled?.items.find((i) => i.id === "undo")?.disabled).toBe(false);
-		expect(editEnabled?.items.find((i) => i.id === "redo")?.disabled).toBe(false);
-	});
-});
-
-describe("<EditorMenuBar />", () => {
-	// Radix relies on pointer-capture / scroll APIs jsdom does not implement.
-	beforeAll(() => {
-		Element.prototype.hasPointerCapture = vi.fn(() => false);
-		Element.prototype.releasePointerCapture = vi.fn();
-		Element.prototype.scrollIntoView = vi.fn();
-	});
-
-	it("renders the three top-level menu triggers", () => {
-		render(<EditorMenuBar {...makeProps()} />);
-		expect(screen.getByRole("button", { name: "File" })).toBeInTheDocument();
-		expect(screen.getByRole("button", { name: "Edit" })).toBeInTheDocument();
-		expect(screen.getByRole("button", { name: "View" })).toBeInTheDocument();
-	});
-
-	it("opens the File menu and invokes the handler for a selected item", async () => {
-		const user = userEvent.setup();
-		const props = makeProps();
-		render(<EditorMenuBar {...props} />);
-
-		await user.click(screen.getByRole("button", { name: "File" }));
-
-		expect(await screen.findByText("New Project")).toBeInTheDocument();
-		expect(screen.getByText("Ctrl+N")).toBeInTheDocument();
-
-		await user.click(screen.getByText("Save Project…"));
-		expect(props.onSaveProject).toHaveBeenCalledOnce();
-	});
-
-	it("renders a disabled Undo item when canUndo is false", async () => {
-		const user = userEvent.setup();
-		const props = makeProps({ canUndo: false });
-		render(<EditorMenuBar {...props} />);
-
-		await user.click(screen.getByRole("button", { name: "Edit" }));
-
-		const undoItem = await screen.findByRole("menuitem", { name: /Undo/ });
-		expect(undoItem).toHaveAttribute("aria-disabled", "true");
-	});
-});
diff --git a/src/components/video-editor/EditorMenuBar.tsx b/src/components/video-editor/EditorMenuBar.tsx
deleted file mode 100644
index 629f66482a..0000000000
--- a/src/components/video-editor/EditorMenuBar.tsx
+++ /dev/null
@@ -1,198 +0,0 @@
-import { Fragment } from "react";
-import {
-	DropdownMenu,
-	DropdownMenuContent,
-	DropdownMenuItem,
-	DropdownMenuSeparator,
-	DropdownMenuShortcut,
-	DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu";
-
-export interface EditorMenuBarProps {
-	/** Whether the app is running on macOS. Drives shortcut-hint formatting. */
-	isMac: boolean;
-	/** Qualified-key translator (e.g. the `rawT` from `useI18n`). */
-	t: (qualifiedKey: string) => string;
-	onNewProject: () => void;
-	onLoadProject: () => void;
-	onSaveProject: () => void;
-	onSaveProjectAs: () => void;
-	onQuit: () => void;
-	onUndo: () => void;
-	onRedo: () => void;
-	onReload: () => void;
-	canUndo: boolean;
-	canRedo: boolean;
-}
-
-export interface EditorMenuItem {
-	id: string;
-	label: string;
-	/** Human-readable, platform-aware shortcut hint (e.g. "Ctrl+N" / "⌘N"). */
-	shortcut?: string;
-	onSelect: () => void;
-	disabled?: boolean;
-	/** Renders the item in a destructive (red) style, e.g. Quit. */
-	danger?: boolean;
-	/** Draws a separator immediately before this item. */
-	separatorBefore?: boolean;
-}
-
-export interface EditorMenu {
-	id: string;
-	label: string;
-	minWidthClass: string;
-	items: EditorMenuItem[];
-}
-
-/**
- * Formats a menu shortcut hint for the current platform. macOS uses the symbol
- * modifier with no separator ("⌘N"); everywhere else uses "Ctrl+N". These mirror
- * the accelerators wired in the native menu (electron/main.ts) and the editor
- * keydown handler, so the hints stay truthful.
- */
-export function formatShortcut(isMac: boolean, key: string): string {
-	return isMac ? `⌘${key}` : `Ctrl+${key}`;
-}
-
-export function formatShiftShortcut(isMac: boolean, key: string): string {
-	return isMac ? `⌘⇧${key}` : `Ctrl+Shift+${key}`;
-}
-
-/**
- * Pure description of the editor's File / Edit / View menus. Kept separate from
- * the rendering so the labels, shortcut hints, disabled states, and handler
- * wiring can be unit-tested without mounting Radix/jsdom.
- */
-export function buildEditorMenuModel(props: EditorMenuBarProps): EditorMenu[] {
-	const { isMac, t } = props;
-
-	return [
-		{
-			id: "file",
-			label: t("common.actions.file"),
-			minWidthClass: "min-w-[170px]",
-			items: [
-				{
-					id: "new-project",
-					label: t("dialogs.unsavedChanges.newProject"),
-					shortcut: formatShortcut(isMac, "N"),
-					onSelect: props.onNewProject,
-				},
-				{
-					id: "load-project",
-					label: t("dialogs.unsavedChanges.loadProject"),
-					shortcut: formatShortcut(isMac, "O"),
-					onSelect: props.onLoadProject,
-					separatorBefore: true,
-				},
-				{
-					id: "save-project",
-					label: t("dialogs.unsavedChanges.saveProject"),
-					shortcut: formatShortcut(isMac, "S"),
-					onSelect: props.onSaveProject,
-				},
-				{
-					id: "save-project-as",
-					label: t("dialogs.unsavedChanges.saveProjectAs"),
-					shortcut: formatShiftShortcut(isMac, "S"),
-					onSelect: props.onSaveProjectAs,
-				},
-				{
-					id: "quit",
-					label: t("common.actions.quit"),
-					shortcut: formatShortcut(isMac, "Q"),
-					onSelect: props.onQuit,
-					danger: true,
-					separatorBefore: true,
-				},
-			],
-		},
-		{
-			id: "edit",
-			label: t("common.actions.edit"),
-			minWidthClass: "min-w-[130px]",
-			items: [
-				{
-					id: "undo",
-					label: t("common.actions.undo"),
-					shortcut: formatShortcut(isMac, "Z"),
-					onSelect: props.onUndo,
-					disabled: !props.canUndo,
-				},
-				{
-					id: "redo",
-					label: t("common.actions.redo"),
-					// Redo is bound to both Ctrl+Y and Ctrl+Shift+Z; show the
-					// idiomatic hint per platform (⌘⇧Z on macOS, Ctrl+Y elsewhere).
-					shortcut: isMac ? formatShiftShortcut(isMac, "Z") : formatShortcut(isMac, "Y"),
-					onSelect: props.onRedo,
-					disabled: !props.canRedo,
-				},
-			],
-		},
-		{
-			id: "view",
-			label: t("common.actions.view"),
-			minWidthClass: "min-w-[130px]",
-			items: [
-				{
-					id: "reload",
-					label: t("common.actions.reload"),
-					shortcut: formatShortcut(isMac, "R"),
-					onSelect: props.onReload,
-				},
-			],
-		},
-	];
-}
-
-/**
- * Custom in-app menu bar (File / Edit / View) shown in the editor's titlebar.
- * Replaces the native OS menu bar that is auto-hidden on Windows/Linux
- * (see electron/windows.ts).
- */
-export function EditorMenuBar(props: EditorMenuBarProps) {
-	const menus = buildEditorMenuModel(props);
-
-	return (
-		<div className={`flex items-center gap-0.5 ${props.isMac ? "ml-14" : "ml-2"}`}>
-			{menus.map((menu) => (
-				<DropdownMenu key={menu.id}>
-					<DropdownMenuTrigger asChild>
-						<button
-							type="button"
-							className="px-2.5 py-1.5 rounded-lg text-[13px] font-semibold text-slate-300 hover:text-white hover:bg-white/[0.08] transition-all duration-150 outline-none focus-visible:ring-1 focus-visible:ring-white/20 focus-visible:bg-white/[0.08]"
-						>
-							{menu.label}
-						</button>
-					</DropdownMenuTrigger>
-					<DropdownMenuContent
-						align="start"
-						className={`bg-[#09090b]/95 backdrop-blur-md border border-white/[0.08] text-slate-200 ${menu.minWidthClass}`}
-					>
-						{menu.items.map((item) => (
-							<Fragment key={item.id}>
-								{item.separatorBefore && <DropdownMenuSeparator className="bg-white/[0.08]" />}
-								<DropdownMenuItem
-									onSelect={() => item.onSelect()}
-									disabled={item.disabled}
-									className={
-										item.danger
-											? "hover:bg-red-500/20 focus:bg-red-500/20 focus:text-red-400 text-red-400 cursor-pointer justify-between"
-											: "hover:bg-white/[0.08] focus:bg-white/[0.08] focus:text-white cursor-pointer justify-between"
-									}
-								>
-									<span>{item.label}</span>
-									{item.shortcut && (
-										<DropdownMenuShortcut className="ml-2">{item.shortcut}</DropdownMenuShortcut>
-									)}
-								</DropdownMenuItem>
-							</Fragment>
-						))}
-					</DropdownMenuContent>
-				</DropdownMenu>
-			))}
-		</div>
-	);
-}
diff --git a/src/components/video-editor/backgroundImageUpload.test.ts b/src/components/video-editor/backgroundImageUpload.test.ts
deleted file mode 100644
index d83ca3a03e..0000000000
--- a/src/components/video-editor/backgroundImageUpload.test.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isSupportedBackgroundImageType } from "./backgroundImageUpload";
-
-describe("background image upload validation", () => {
-	it("accepts PNG images for custom backgrounds", () => {
-		expect(isSupportedBackgroundImageType("image/png", "生成画像1.png")).toBe(true);
-	});
-
-	it("accepts PNG images by extension when the browser does not provide a MIME type", () => {
-		expect(isSupportedBackgroundImageType("", "生成画像1.png")).toBe(true);
-	});
-
-	it("keeps rejecting non-image uploads", () => {
-		expect(isSupportedBackgroundImageType("text/plain", "notes.txt")).toBe(false);
-	});
-
-	it("does not allow extension fallback for explicit unsupported MIME types", () => {
-		expect(isSupportedBackgroundImageType("text/plain", "notes.png")).toBe(false);
-	});
-});
diff --git a/src/components/video-editor/backgroundImageUpload.ts b/src/components/video-editor/backgroundImageUpload.ts
deleted file mode 100644
index ebc256a2be..0000000000
--- a/src/components/video-editor/backgroundImageUpload.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-const SUPPORTED_BACKGROUND_IMAGE_TYPES = new Set(["image/jpeg", "image/jpg", "image/png"]);
-const SUPPORTED_BACKGROUND_IMAGE_EXTENSIONS = new Set([".jpg", ".jpeg", ".png"]);
-
-export const BACKGROUND_IMAGE_ACCEPT = ".jpg,.jpeg,.png,image/jpeg,image/png";
-
-export function isSupportedBackgroundImageType(type: string, fileName: string): boolean {
-	const normalizedType = type.trim().toLowerCase();
-	if (SUPPORTED_BACKGROUND_IMAGE_TYPES.has(normalizedType)) {
-		return true;
-	}
-
-	if (normalizedType) {
-		return false;
-	}
-
-	const lowerName = fileName.trim().toLowerCase();
-	return [...SUPPORTED_BACKGROUND_IMAGE_EXTENSIONS].some((extension) =>
-		lowerName.endsWith(extension),
-	);
-}
diff --git a/src/components/video-editor/regionClipboard.test.ts b/src/components/video-editor/regionClipboard.test.ts
deleted file mode 100644
index f99f17eb27..0000000000
--- a/src/components/video-editor/regionClipboard.test.ts
+++ /dev/null
@@ -1,203 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	buildPastedAnnotation,
-	buildSpeedRegion,
-	buildZoomRegion,
-	extractAnnotationAttributes,
-	extractSpeedAttributes,
-	extractZoomAttributes,
-	replaceAnnotationAttributes,
-} from "./regionClipboard";
-import {
-	type AnnotationRegion,
-	DEFAULT_ANNOTATION_POSITION,
-	DEFAULT_ANNOTATION_SIZE,
-	DEFAULT_ANNOTATION_STYLE,
-	DEFAULT_FIGURE_DATA,
-	type SpeedRegion,
-	type ZoomRegion,
-} from "./types";
-
-const zoom: ZoomRegion = {
-	id: "zoom-1",
-	startMs: 1000,
-	endMs: 3000,
-	depth: 4,
-	customScale: 2.75,
-	focus: { cx: 0.2, cy: 0.8 },
-	focusMode: "manual",
-	rotationPreset: "iso",
-	source: "manual",
-};
-
-const speed: SpeedRegion = { id: "speed-1", startMs: 0, endMs: 500, speed: 2 };
-
-const annotation: AnnotationRegion = {
-	id: "annotation-1",
-	startMs: 0,
-	endMs: 2000,
-	type: "figure",
-	content: "hello",
-	position: { x: 10, y: 90 },
-	size: { width: 40, height: 25 },
-	style: { ...DEFAULT_ANNOTATION_STYLE, color: "#ff0000", textAnimation: "pop" },
-	zIndex: 3,
-	figureData: { ...DEFAULT_FIGURE_DATA, color: "#123456" },
-};
-
-describe("zoom attribute copy/paste", () => {
-	it("round-trips the copyable attributes onto a different clip while keeping its identity/timing", () => {
-		const attrs = extractZoomAttributes(zoom);
-		const target: ZoomRegion = {
-			id: "zoom-2",
-			startMs: 9000,
-			endMs: 9500,
-			depth: 1,
-			focus: { cx: 0.5, cy: 0.5 },
-			source: "manual",
-		};
-		const result = buildZoomRegion(target, attrs);
-
-		expect(result.id).toBe("zoom-2");
-		expect(result.startMs).toBe(9000);
-		expect(result.endMs).toBe(9500);
-		expect(result.depth).toBe(4);
-		expect(result.customScale).toBe(2.75);
-		expect(result.focus).toEqual({ cx: 0.2, cy: 0.8 });
-		expect(result.focusMode).toBe("manual");
-		expect(result.rotationPreset).toBe("iso");
-	});
-
-	it("deep-copies focus so the source and target are decoupled", () => {
-		const attrs = extractZoomAttributes(zoom);
-		const result = buildZoomRegion({ ...zoom, id: "zoom-2" }, attrs);
-		result.focus.cx = 0.99;
-		expect(zoom.focus.cx).toBe(0.2);
-	});
-});
-
-describe("speed attribute copy/paste", () => {
-	it("copies only the speed value", () => {
-		const attrs = extractSpeedAttributes(speed);
-		const target: SpeedRegion = { id: "speed-2", startMs: 4000, endMs: 5000, speed: 1 };
-		const result = buildSpeedRegion(target, attrs);
-		expect(result).toEqual({ id: "speed-2", startMs: 4000, endMs: 5000, speed: 2 });
-	});
-});
-
-describe("annotation copy captures everything", () => {
-	it("captures styling plus content, type, and position", () => {
-		const attrs = extractAnnotationAttributes(annotation);
-		expect(attrs.type).toBe("figure");
-		expect(attrs.content).toBe("hello");
-		expect(attrs.position).toEqual({ x: 10, y: 90 });
-		expect(attrs.style.color).toBe("#ff0000");
-		expect(attrs.figureData?.color).toBe("#123456");
-	});
-});
-
-describe("paste onto an existing annotation applies styling only", () => {
-	it("overwrites the look/feel but keeps the target's content, position, timing, and zIndex", () => {
-		const attrs = extractAnnotationAttributes(annotation);
-		const target: AnnotationRegion = {
-			id: "annotation-2",
-			startMs: 7000,
-			endMs: 8000,
-			type: "text",
-			content: "world",
-			position: { ...DEFAULT_ANNOTATION_POSITION },
-			size: { ...DEFAULT_ANNOTATION_SIZE },
-			style: { ...DEFAULT_ANNOTATION_STYLE },
-			zIndex: 9,
-		};
-		const result = replaceAnnotationAttributes(target, attrs);
-
-		expect(result.content).toBe("world");
-		expect(result.position).toEqual(DEFAULT_ANNOTATION_POSITION);
-		expect(result.startMs).toBe(7000);
-		expect(result.zIndex).toBe(9);
-		expect(result.style.color).toBe("#ff0000");
-		expect(result.style.textAnimation).toBe("pop");
-		expect(result.size).toEqual({ width: 40, height: 25 });
-		// Target is text, so the copied figure's figureData must NOT attach (F5 guard).
-		expect(result.figureData).toBeUndefined();
-	});
-
-	it("keeps the target's own figure data when the copied region has none", () => {
-		const textAttrs = extractAnnotationAttributes({ ...annotation, figureData: undefined });
-		const figureTarget: AnnotationRegion = { ...annotation, id: "annotation-3" };
-		const result = replaceAnnotationAttributes(figureTarget, textAttrs);
-		expect(result.figureData?.color).toBe("#123456");
-	});
-});
-
-describe("paste as a new annotation clones the full copy", () => {
-	it("clones type, content, styling, and position; takes timing/identity from the base", () => {
-		const attrs = extractAnnotationAttributes(annotation);
-		const result = buildPastedAnnotation(
-			{ id: "annotation-4", startMs: 12000, endMs: 14000, zIndex: 5 },
-			attrs,
-		);
-
-		expect(result.id).toBe("annotation-4");
-		expect(result.startMs).toBe(12000);
-		expect(result.endMs).toBe(14000);
-		expect(result.zIndex).toBe(5);
-		expect(result.type).toBe("figure");
-		expect(result.content).toBe("hello");
-		expect(result.position).toEqual({ x: 10, y: 90 });
-		expect(result.style.color).toBe("#ff0000");
-		expect(result.figureData?.color).toBe("#123456");
-	});
-
-	it("deep-copies position so source and clone are decoupled", () => {
-		const attrs = extractAnnotationAttributes(annotation);
-		const result = buildPastedAnnotation(
-			{ id: "annotation-5", startMs: 0, endMs: 1000, zIndex: 1 },
-			attrs,
-		);
-		result.position.x = 99;
-		expect(annotation.position.x).toBe(10);
-	});
-});
-
-describe("zoom paste replaces customScale destructively (F4)", () => {
-	it("clears the target's customScale when the copied zoom is preset-only", () => {
-		const presetOnly = extractZoomAttributes({ ...zoom, customScale: undefined });
-		const target: ZoomRegion = { ...zoom, id: "zoom-3", customScale: 1.5 };
-		const result = buildZoomRegion(target, presetOnly);
-		expect(result.customScale).toBeUndefined();
-	});
-});
-
-describe("figureData guard on paste-onto-existing (F5)", () => {
-	it("does not attach figureData onto a non-figure target", () => {
-		const figureAttrs = extractAnnotationAttributes(annotation);
-		const textTarget: AnnotationRegion = {
-			id: "annotation-6",
-			startMs: 0,
-			endMs: 1000,
-			type: "text",
-			content: "hi",
-			position: { ...DEFAULT_ANNOTATION_POSITION },
-			size: { ...DEFAULT_ANNOTATION_SIZE },
-			style: { ...DEFAULT_ANNOTATION_STYLE },
-			zIndex: 1,
-		};
-		const result = replaceAnnotationAttributes(textTarget, figureAttrs);
-		expect(result.figureData).toBeUndefined();
-		// Styling still applies regardless of type.
-		expect(result.style.color).toBe("#ff0000");
-	});
-
-	it("applies figureData when the target is itself a figure", () => {
-		const figureAttrs = extractAnnotationAttributes(annotation);
-		const figureTarget: AnnotationRegion = {
-			...annotation,
-			id: "annotation-7",
-			figureData: { ...DEFAULT_FIGURE_DATA, color: "#000000" },
-		};
-		const result = replaceAnnotationAttributes(figureTarget, figureAttrs);
-		expect(result.figureData?.color).toBe("#123456");
-	});
-});
diff --git a/src/components/video-editor/regionClipboard.ts b/src/components/video-editor/regionClipboard.ts
deleted file mode 100644
index 876da43875..0000000000
--- a/src/components/video-editor/regionClipboard.ts
+++ /dev/null
@@ -1,158 +0,0 @@
-import type {
-	AnnotationPosition,
-	AnnotationRegion,
-	AnnotationSize,
-	AnnotationTextStyle,
-	AnnotationType,
-	BlurData,
-	FigureData,
-	PlaybackSpeed,
-	Rotation3DPreset,
-	SpeedRegion,
-	ZoomDepth,
-	ZoomFocus,
-	ZoomFocusMode,
-	ZoomRegion,
-} from "./types";
-
-/** The copyable attributes of each region, tagged with its `kind` so paste can discriminate.
- * Trim has no attributes, so it isn't copyable. */
-export type CopiedZoom = {
-	kind: "zoom";
-	depth: ZoomDepth;
-	customScale?: number;
-	focus: ZoomFocus;
-	focusMode?: ZoomFocusMode;
-	rotationPreset?: Rotation3DPreset;
-};
-
-export type CopiedSpeed = { kind: "speed"; speed: PlaybackSpeed };
-
-/** Annotation copy captures everything; paste then uses only the styling for an existing
- * region, or the full set for a brand-new one. */
-export type CopiedAnnotation = {
-	kind: "annotation";
-	// Styling — applied both when pasting onto an existing region and onto a new one.
-	style: AnnotationTextStyle;
-	size: AnnotationSize;
-	figureData?: FigureData;
-	blurData?: BlurData;
-	// Content & placement — used only when pasting as a brand-new region.
-	type: AnnotationType;
-	content: string;
-	textContent?: string;
-	imageContent?: string;
-	position: AnnotationPosition;
-};
-
-export type CopiedRegion = CopiedZoom | CopiedSpeed | CopiedAnnotation;
-
-/** Session clipboard for "copy/paste region attributes" (not undoable, not persisted).
- * Module-level so it's shared regardless of which editor instance copied. */
-let clipboard: CopiedRegion | null = null;
-
-export function getCopiedRegion(): CopiedRegion | null {
-	return clipboard;
-}
-
-export function setCopiedRegion(region: CopiedRegion): void {
-	clipboard = region;
-}
-
-export function extractZoomAttributes(region: ZoomRegion): CopiedZoom {
-	return {
-		kind: "zoom",
-		depth: region.depth,
-		customScale: region.customScale,
-		focus: { ...region.focus },
-		focusMode: region.focusMode,
-		rotationPreset: region.rotationPreset,
-	};
-}
-
-export function extractSpeedAttributes(region: SpeedRegion): CopiedSpeed {
-	return { kind: "speed", speed: region.speed };
-}
-
-/** Deep-clones blur data, including its nested freehand points array. */
-function cloneBlurData(blurData?: BlurData): BlurData | undefined {
-	if (!blurData) return undefined;
-	return {
-		...blurData,
-		freehandPoints: blurData.freehandPoints ? [...blurData.freehandPoints] : undefined,
-	};
-}
-
-export function extractAnnotationAttributes(region: AnnotationRegion): CopiedAnnotation {
-	return {
-		kind: "annotation",
-		style: { ...region.style },
-		size: { ...region.size },
-		figureData: region.figureData ? { ...region.figureData } : undefined,
-		blurData: cloneBlurData(region.blurData),
-		type: region.type,
-		content: region.content,
-		textContent: region.textContent,
-		imageContent: region.imageContent,
-		position: { ...region.position },
-	};
-}
-
-/** Returns a region carrying the copied attributes. Identity, timing, and source come from
- * `base` (so a full region keeps its own); every attribute comes from the copy, with nested
- * objects deep-copied. Passing a stub `base` builds a brand-new region; passing an existing
- * region overwrites ALL its attributes (e.g. a preset-only copy clears the target's customScale). */
-export function buildZoomRegion(
-	base: Pick<ZoomRegion, "id" | "startMs" | "endMs" | "source">,
-	attrs: CopiedZoom,
-): ZoomRegion {
-	const { kind: _kind, ...zoomAttrs } = attrs;
-	return { ...base, ...zoomAttrs, focus: { ...zoomAttrs.focus } };
-}
-
-export function buildSpeedRegion(
-	base: Pick<SpeedRegion, "id" | "startMs" | "endMs">,
-	attrs: CopiedSpeed,
-): SpeedRegion {
-	return { ...base, speed: attrs.speed };
-}
-
-/** Pastes onto an EXISTING annotation: only the styling is overwritten — the target keeps
- * its own type, text/image content, position, timing, and stacking order. */
-export function replaceAnnotationAttributes(
-	region: AnnotationRegion,
-	attrs: CopiedAnnotation,
-): AnnotationRegion {
-	return {
-		...region,
-		style: { ...attrs.style },
-		size: { ...attrs.size },
-		// Only carry figure data onto a figure target; never attach it to a non-figure
-		// (e.g. pasting a figure's attributes onto a text annotation keeps the text figure-less).
-		figureData:
-			region.type === "figure" && attrs.figureData ? { ...attrs.figureData } : region.figureData,
-		// Likewise, only carry blur settings onto a blur target.
-		blurData:
-			region.type === "blur" && attrs.blurData ? cloneBlurData(attrs.blurData) : region.blurData,
-	};
-}
-
-/** Builds a BRAND-NEW annotation from a full copy: clones type, content, styling, size,
- * figure data, and position. Identity, timing, and stacking order come from `base`. */
-export function buildPastedAnnotation(
-	base: Pick<AnnotationRegion, "id" | "startMs" | "endMs" | "zIndex">,
-	attrs: CopiedAnnotation,
-): AnnotationRegion {
-	return {
-		...base,
-		type: attrs.type,
-		content: attrs.content,
-		textContent: attrs.textContent,
-		imageContent: attrs.imageContent,
-		position: { ...attrs.position },
-		size: { ...attrs.size },
-		style: { ...attrs.style },
-		figureData: attrs.figureData ? { ...attrs.figureData } : undefined,
-		blurData: cloneBlurData(attrs.blurData),
-	};
-}
diff --git a/src/components/video-editor/regionPlacement.test.ts b/src/components/video-editor/regionPlacement.test.ts
deleted file mode 100644
index ecddf2ff61..0000000000
--- a/src/components/video-editor/regionPlacement.test.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { findFreeGapAt } from "./regionPlacement";
-
-const totalMs = 10000;
-
-describe("findFreeGapAt", () => {
-	it("returns the gap to the end when there are no regions", () => {
-		const { ok, gapMs } = findFreeGapAt([], 2000, totalMs);
-		expect(ok).toBe(true);
-		expect(gapMs).toBe(8000);
-	});
-
-	it("rejects a playhead that lands inside an existing region", () => {
-		const regions = [{ startMs: 1000, endMs: 4000 }];
-		const { ok } = findFreeGapAt(regions, 2000, totalMs);
-		expect(ok).toBe(false);
-	});
-
-	it("clamps the gap to the next region's start", () => {
-		const regions = [{ startMs: 5000, endMs: 7000 }];
-		const { ok, gapMs } = findFreeGapAt(regions, 2000, totalMs);
-		expect(ok).toBe(true);
-		expect(gapMs).toBe(3000);
-	});
-
-	it("rejects placement with no room before the end", () => {
-		const { ok, gapMs } = findFreeGapAt([], totalMs, totalMs);
-		expect(ok).toBe(false);
-		expect(gapMs).toBe(0);
-	});
-
-	it("rejects placement that lands exactly on a region's startMs", () => {
-		const regions = [{ startMs: 5000, endMs: 7000 }];
-		const { ok } = findFreeGapAt(regions, 5000, totalMs);
-		expect(ok).toBe(false);
-	});
-
-	it("allows placement adjacent to (exactly at the end of) an existing region", () => {
-		const regions = [{ startMs: 0, endMs: 2000 }];
-		const { ok, gapMs } = findFreeGapAt(regions, 2000, totalMs);
-		expect(ok).toBe(true);
-		expect(gapMs).toBe(8000);
-	});
-
-	it("sorts unordered regions before computing the next gap", () => {
-		const regions = [
-			{ startMs: 8000, endMs: 9000 },
-			{ startMs: 3000, endMs: 4000 },
-		];
-		const { ok, gapMs } = findFreeGapAt(regions, 1000, totalMs);
-		expect(ok).toBe(true);
-		expect(gapMs).toBe(2000);
-	});
-});
diff --git a/src/components/video-editor/regionPlacement.ts b/src/components/video-editor/regionPlacement.ts
deleted file mode 100644
index 673d3fe7f8..0000000000
--- a/src/components/video-editor/regionPlacement.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * Find the available gap at `startPos` in a list of regions.
- *
- * Looks at the span from `startPos` up to the start of the next region
- * (or up to `totalMs` if there is no later region) and reports its size,
- * along with whether placement at `startPos` is actually valid.
- *
- * Placement is valid as long as `startPos` does not fall inside an
- * existing region and there is some room before the next one. Landing
- * exactly on the end of an existing region is fine (adjacency is
- * allowed); landing on a region's start or strictly between its start
- * and end, or having zero space left before the next region, is not.
- */
-export function findFreeGapAt(
-	regions: ReadonlyArray<{ startMs: number; endMs: number }>,
-	startPos: number,
-	totalMs: number,
-): { ok: boolean; gapMs: number } {
-	const sorted = [...regions].sort((a, b) => a.startMs - b.startMs);
-	const nextRegion = sorted.find((r) => r.startMs > startPos);
-	const gapMs = nextRegion ? nextRegion.startMs - startPos : totalMs - startPos;
-	const overlapping = sorted.some((r) => startPos >= r.startMs && startPos < r.endMs);
-	return { ok: !overlapping && gapMs > 0, gapMs };
-}
diff --git a/src/i18n/locales/ar/editor.json b/src/i18n/locales/ar/editor.json
index f5e1a7ddc2..a9f931f15e 100644
--- a/src/i18n/locales/ar/editor.json
+++ b/src/i18n/locales/ar/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "فشل التصدير",
 		"failedToWriteFile": "فشلت كتابة الملف",
 		"qualityUpscaleWarning": "تكبير الدقة",
-		"exportedVideoOf": "من الفيديو تم تصديره في"
+		"exportedVideoOf": "من الفيديو تم تصديره في",
+		"nothingToExport": "لا يوجد شيء للتصدير — المخطط الزمني فارغ."
 	},
 	"inspector": {
 		"resetFocusPoint": "إعادة تعيين نقطة التركيز",
diff --git a/src/i18n/locales/en/editor.json b/src/i18n/locales/en/editor.json
index aa3fd48fb9..4e1c39a3b5 100644
--- a/src/i18n/locales/en/editor.json
+++ b/src/i18n/locales/en/editor.json
@@ -205,7 +205,8 @@
 		"showInFolder": "Show in folder",
 		"exportFailed": "Export failed",
 		"failedToWriteFile": "Failed to write file",
-		"qualityUpscaleWarning": "Upscale"
+		"qualityUpscaleWarning": "Upscale",
+		"nothingToExport": "Nothing to export — the timeline is empty."
 	},
 	"inspector": {
 		"resetFocusPoint": "Reset focus point",
diff --git a/src/i18n/locales/es/editor.json b/src/i18n/locales/es/editor.json
index 3fc8635884..da5379322f 100644
--- a/src/i18n/locales/es/editor.json
+++ b/src/i18n/locales/es/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "Error al exportar",
 		"failedToWriteFile": "No se pudo escribir el archivo",
 		"qualityUpscaleWarning": "Upscaling",
-		"exportedVideoOf": "de vídeo exportado en"
+		"exportedVideoOf": "de vídeo exportado en",
+		"nothingToExport": "Nada que exportar: la línea de tiempo está vacía."
 	},
 	"inspector": {
 		"resetFocusPoint": "Restablecer punto de enfoque",
diff --git a/src/i18n/locales/fr/editor.json b/src/i18n/locales/fr/editor.json
index 3f84a85502..1d3ea011f9 100644
--- a/src/i18n/locales/fr/editor.json
+++ b/src/i18n/locales/fr/editor.json
@@ -205,7 +205,8 @@
 		"showInFolder": "Afficher dans le dossier",
 		"exportFailed": "Échec de l'export",
 		"failedToWriteFile": "Échec de l'écriture du fichier",
-		"qualityUpscaleWarning": "Upscaling"
+		"qualityUpscaleWarning": "Upscaling",
+		"nothingToExport": "Rien à exporter — la timeline est vide."
 	},
 	"inspector": {
 		"resetFocusPoint": "Réinitialiser le point de focus",
diff --git a/src/i18n/locales/it/editor.json b/src/i18n/locales/it/editor.json
index fa1365d282..079a0ef27e 100644
--- a/src/i18n/locales/it/editor.json
+++ b/src/i18n/locales/it/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "Esportazione non riuscita",
 		"failedToWriteFile": "Impossibile scrivere il file",
 		"qualityUpscaleWarning": "Upscaling",
-		"exportedVideoOf": "di video esportato in"
+		"exportedVideoOf": "di video esportato in",
+		"nothingToExport": "Niente da esportare: la timeline è vuota."
 	},
 	"inspector": {
 		"resetFocusPoint": "Reimposta punto di messa a fuoco",
diff --git a/src/i18n/locales/ja-JP/editor.json b/src/i18n/locales/ja-JP/editor.json
index de6283dc14..445e7f163f 100644
--- a/src/i18n/locales/ja-JP/editor.json
+++ b/src/i18n/locales/ja-JP/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "エクスポートに失敗しました",
 		"failedToWriteFile": "ファイルの書き込みに失敗しました",
 		"qualityUpscaleWarning": "アップスケール",
-		"exportedVideoOf": "の動画を書き出しました。所要時間:"
+		"exportedVideoOf": "の動画を書き出しました。所要時間:",
+		"nothingToExport": "書き出す内容がありません — タイムラインが空です。"
 	},
 	"inspector": {
 		"resetFocusPoint": "フォーカスポイントをリセット",
diff --git a/src/i18n/locales/ko-KR/editor.json b/src/i18n/locales/ko-KR/editor.json
index ed83e85e95..60012d55fd 100644
--- a/src/i18n/locales/ko-KR/editor.json
+++ b/src/i18n/locales/ko-KR/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "내보내기 실패",
 		"failedToWriteFile": "파일 쓰기에 실패했습니다",
 		"qualityUpscaleWarning": "업스케일",
-		"exportedVideoOf": "분량의 영상을 내보냈습니다. 소요 시간:"
+		"exportedVideoOf": "분량의 영상을 내보냈습니다. 소요 시간:",
+		"nothingToExport": "내보낼 항목이 없습니다 — 타임라인이 비어 있습니다."
 	},
 	"inspector": {
 		"resetFocusPoint": "포커스 지점 재설정",
diff --git a/src/i18n/locales/pt-BR/editor.json b/src/i18n/locales/pt-BR/editor.json
index 165426e4ee..82534fac8e 100644
--- a/src/i18n/locales/pt-BR/editor.json
+++ b/src/i18n/locales/pt-BR/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "Falha na exportação",
 		"failedToWriteFile": "Falha ao gravar o arquivo",
 		"qualityUpscaleWarning": "Upscaling",
-		"exportedVideoOf": "de vídeo exportado em"
+		"exportedVideoOf": "de vídeo exportado em",
+		"nothingToExport": "Nada para exportar — a linha do tempo está vazia."
 	},
 	"inspector": {
 		"resetFocusPoint": "Redefinir ponto de foco",
diff --git a/src/i18n/locales/ru/editor.json b/src/i18n/locales/ru/editor.json
index 06592ef818..6e3c4199e5 100644
--- a/src/i18n/locales/ru/editor.json
+++ b/src/i18n/locales/ru/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "Ошибка экспорта",
 		"failedToWriteFile": "Не удалось записать файл",
 		"qualityUpscaleWarning": "Апскейл",
-		"exportedVideoOf": "видео экспортировано за"
+		"exportedVideoOf": "видео экспортировано за",
+		"nothingToExport": "Нечего экспортировать — таймлайн пуст."
 	},
 	"inspector": {
 		"resetFocusPoint": "Сбросить точку фокуса",
diff --git a/src/i18n/locales/tr/editor.json b/src/i18n/locales/tr/editor.json
index d0b927586e..ba94a2f00d 100644
--- a/src/i18n/locales/tr/editor.json
+++ b/src/i18n/locales/tr/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "Dışa aktarma başarısız oldu",
 		"failedToWriteFile": "Dosya yazılamadı",
 		"qualityUpscaleWarning": "Upscale",
-		"exportedVideoOf": "video şu sürede dışa aktarıldı:"
+		"exportedVideoOf": "video şu sürede dışa aktarıldı:",
+		"nothingToExport": "Dışa aktarılacak bir şey yok — zaman çizelgesi boş."
 	},
 	"inspector": {
 		"resetFocusPoint": "Odak noktasını sıfırla",
diff --git a/src/i18n/locales/vi/editor.json b/src/i18n/locales/vi/editor.json
index 5b16f995b5..1589b62584 100644
--- a/src/i18n/locales/vi/editor.json
+++ b/src/i18n/locales/vi/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "Xuất thất bại",
 		"failedToWriteFile": "Không thể ghi tệp",
 		"qualityUpscaleWarning": "Upscale",
-		"exportedVideoOf": "video đã xuất trong"
+		"exportedVideoOf": "video đã xuất trong",
+		"nothingToExport": "Không có gì để xuất — dòng thời gian trống."
 	},
 	"inspector": {
 		"resetFocusPoint": "Đặt lại điểm lấy nét",
diff --git a/src/i18n/locales/zh-CN/editor.json b/src/i18n/locales/zh-CN/editor.json
index b9c0ebe2f2..82643672a3 100644
--- a/src/i18n/locales/zh-CN/editor.json
+++ b/src/i18n/locales/zh-CN/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "导出失败",
 		"failedToWriteFile": "写入文件失败",
 		"qualityUpscaleWarning": "放大",
-		"exportedVideoOf": "的视频已导出，用时"
+		"exportedVideoOf": "的视频已导出，用时",
+		"nothingToExport": "没有可导出的内容 — 时间轴为空。"
 	},
 	"inspector": {
 		"resetFocusPoint": "重置焦点",
diff --git a/src/i18n/locales/zh-TW/editor.json b/src/i18n/locales/zh-TW/editor.json
index 478e4ef336..d8e0487a25 100644
--- a/src/i18n/locales/zh-TW/editor.json
+++ b/src/i18n/locales/zh-TW/editor.json
@@ -205,7 +205,8 @@
 		"exportFailed": "匯出失敗",
 		"failedToWriteFile": "寫入檔案失敗",
 		"qualityUpscaleWarning": "放大",
-		"exportedVideoOf": "的影片已匯出，耗時"
+		"exportedVideoOf": "的影片已匯出，耗時",
+		"nothingToExport": "沒有可匯出的內容 — 時間軸為空。"
 	},
 	"inspector": {
 		"resetFocusPoint": "重設焦點",
diff --git a/src/lib/ai-edition/annotations/background.test.ts b/src/lib/ai-edition/annotations/background.test.ts
index 4e86976089..cd0f07199b 100644
--- a/src/lib/ai-edition/annotations/background.test.ts
+++ b/src/lib/ai-edition/annotations/background.test.ts
@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+import { DEFAULT_ANNOTATION_STYLE } from "@/components/video-editor/types";
 import type { AxcutAnnotationRegion } from "@/lib/ai-edition/schema";
 import {
 	DEFAULT_TEXT_BACKGROUND,
@@ -7,7 +8,6 @@ import {
 	textBackgroundColor,
 	toggleTextBackground,
 } from "./background";
-import { DEFAULT_ANNOTATION_STYLE } from "./constants";
 
 type AnnotationStyle = AxcutAnnotationRegion["style"];
 
diff --git a/src/lib/ai-edition/annotations/blurEffects.ts b/src/lib/ai-edition/annotations/blurEffects.ts
deleted file mode 100644
index 7c0fe3ea80..0000000000
--- a/src/lib/ai-edition/annotations/blurEffects.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-// Port of `src/lib/blurEffects.ts` (the preview-facing helpers only —
-// `applyMosaicToImageData` is export-pipeline-only and unused by the live
-// preview, so it isn't ported here).
-
-import type { AxcutAnnotationRegion } from "@/lib/ai-edition/schema";
-import {
-	DEFAULT_BLUR_BLOCK_SIZE,
-	DEFAULT_BLUR_INTENSITY,
-	MAX_BLUR_BLOCK_SIZE,
-	MAX_BLUR_INTENSITY,
-	MIN_BLUR_BLOCK_SIZE,
-	MIN_BLUR_INTENSITY,
-} from "./constants";
-
-type BlurData = NonNullable<AxcutAnnotationRegion["blurData"]>;
-type BlurColor = BlurData["color"];
-
-function clamp(value: number, min: number, max: number) {
-	if (!Number.isFinite(value)) return min;
-	return Math.min(max, Math.max(min, value));
-}
-
-export function normalizeBlurColor(value: unknown): BlurColor {
-	return value === "black" ? "black" : "white";
-}
-
-export function getNormalizedBlurIntensity(blurData?: BlurData | null): number {
-	return clamp(
-		blurData?.intensity ?? DEFAULT_BLUR_INTENSITY,
-		MIN_BLUR_INTENSITY,
-		MAX_BLUR_INTENSITY,
-	);
-}
-
-export function getNormalizedMosaicBlockSize(blurData?: BlurData | null, scaleFactor = 1): number {
-	const rawBlockSize = clamp(
-		blurData?.blockSize ?? DEFAULT_BLUR_BLOCK_SIZE,
-		MIN_BLUR_BLOCK_SIZE,
-		MAX_BLUR_BLOCK_SIZE,
-	);
-	return Math.max(1, Math.round(rawBlockSize * Math.max(scaleFactor, 0.01)));
-}
-
-export function getBlurOverlayColor(blurData?: BlurData | null): string {
-	const blurColor = normalizeBlurColor(blurData?.color);
-	return blurColor === "black" ? "rgba(0, 0, 0, 0.72)" : "rgba(255, 255, 255, 0.06)";
-}
-
-export function getMosaicGridOverlayColor(blurData?: BlurData | null): string {
-	return normalizeBlurColor(blurData?.color) === "black"
-		? "rgba(255,255,255,0.05)"
-		: "rgba(255,255,255,0.04)";
-}
diff --git a/src/lib/ai-edition/annotations/constants.ts b/src/lib/ai-edition/annotations/constants.ts
deleted file mode 100644
index 3f4ae80813..0000000000
--- a/src/lib/ai-edition/annotations/constants.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-// Defaults ported verbatim from `src/components/video-editor/types.ts` so
-// newly-created annotations look identical between the legacy and new editor.
-
-import type { AxcutAnnotationRegion } from "@/lib/ai-edition/schema";
-
-type AnnotationStyle = AxcutAnnotationRegion["style"];
-type BlurData = NonNullable<AxcutAnnotationRegion["blurData"]>;
-type FigureData = NonNullable<AxcutAnnotationRegion["figureData"]>;
-
-export const DEFAULT_ANNOTATION_POSITION = { x: 50, y: 50 };
-export const DEFAULT_ANNOTATION_SIZE = { width: 30, height: 20 };
-
-export const DEFAULT_ANNOTATION_STYLE: AnnotationStyle = {
-	color: "#ffffff",
-	backgroundColor: "transparent",
-	fontSize: 32,
-	fontFamily: "Inter",
-	fontWeight: "bold",
-	fontStyle: "normal",
-	textDecoration: "none",
-	textAlign: "center",
-	textAnimation: "none",
-};
-
-export const DEFAULT_FIGURE_DATA: FigureData = {
-	arrowDirection: "right",
-	color: "#34B27B",
-	strokeWidth: 4,
-};
-
-export const MIN_BLUR_INTENSITY = 2;
-export const MAX_BLUR_INTENSITY = 40;
-export const DEFAULT_BLUR_INTENSITY = 12;
-export const MIN_BLUR_BLOCK_SIZE = 4;
-export const MAX_BLUR_BLOCK_SIZE = 48;
-export const DEFAULT_BLUR_BLOCK_SIZE = 12;
-
-export const DEFAULT_BLUR_FREEHAND_POINTS: Array<{ x: number; y: number }> = [
-	{ x: 10, y: 30 },
-	{ x: 25, y: 10 },
-	{ x: 55, y: 8 },
-	{ x: 82, y: 20 },
-	{ x: 90, y: 45 },
-	{ x: 78, y: 72 },
-	{ x: 52, y: 90 },
-	{ x: 22, y: 84 },
-	{ x: 8, y: 58 },
-];
-
-export const DEFAULT_BLUR_DATA: BlurData = {
-	type: "mosaic",
-	shape: "rectangle",
-	color: "white",
-	intensity: DEFAULT_BLUR_INTENSITY,
-	blockSize: DEFAULT_BLUR_BLOCK_SIZE,
-	freehandPoints: DEFAULT_BLUR_FREEHAND_POINTS,
-};
diff --git a/src/lib/ai-edition/exporter/audioConcatAssembler.test.ts b/src/lib/ai-edition/exporter/audioConcatAssembler.test.ts
deleted file mode 100644
index 1b41886a01..0000000000
--- a/src/lib/ai-edition/exporter/audioConcatAssembler.test.ts
+++ /dev/null
@@ -1,427 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	type AssembleOptions,
-	type AudioConcatAssemblerSegmentInput,
-	assembleConcatenatedPcm,
-} from "./audioConcatAssembler";
-import type { AudioConcatPlan, AudioConcatSegmentPlan } from "./audioConcatPlan";
-
-// --- Factory helpers ---------------------------------------------------------
-
-// `plan` builds a minimal `AudioConcatPlan` literal — the assembler only reads
-// the documented fields (sampleRate, channels, totalSamples, segments[*]),
-// so we don't have to go through `buildAudioConcatPlan` here.
-function plan(
-	segs: AudioConcatSegmentPlan[],
-	header: { sampleRate?: number; channels?: number; totalSamples?: number } = {},
-): AudioConcatPlan {
-	return {
-		sampleRate: header.sampleRate ?? 48_000,
-		channels: header.channels ?? 1,
-		totalSamples: header.totalSamples ?? segs.reduce((acc, s) => acc + s.sampleCount, 0),
-		segments: segs,
-	};
-}
-
-function seg(
-	clipId: string,
-	startSample: number,
-	sampleCount: number,
-	silence: boolean,
-): AudioConcatSegmentPlan {
-	return { clipId, startSample, sampleCount, silence };
-}
-
-function pcm(...channels: number[][]): Float32Array[] {
-	return channels.map((c) => Float32Array.from(c));
-}
-
-function f32(values: number[]): Float32Array {
-	return Float32Array.from(values);
-}
-
-// --- Copy semantics ----------------------------------------------------------
-
-describe("assembleConcatenatedPcm — single segment", () => {
-	it("single mono segment at exact length: pcm samples copied as-is, no fade, no padding", () => {
-		const segPlan = seg("c1", 0, 4, false);
-		const pl = plan([segPlan]);
-		const inputs: AudioConcatAssemblerSegmentInput[] = [{ pcm: pcm([1, 2, 3, 4]) }];
-		const out = assembleConcatenatedPcm(inputs, pl);
-		expect(out).toHaveLength(1);
-		expect(Array.from(out[0])).toEqual([1, 2, 3, 4]);
-		// totalSamples enforces the buffer length — the slot never overflows.
-		expect(out[0].length).toBe(pl.totalSamples);
-	});
-});
-
-describe("assembleConcatenatedPcm — concatenation", () => {
-	it("two mono segments: seg B's samples land at seg B's startSample; output length == totalSamples", () => {
-		// seg A: [10..14), seg B: [14..19) — butt-joined, no overlap.
-		const pl = plan([seg("a", 0, 4, false), seg("b", 4, 5, false)], { totalSamples: 9 });
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([10, 11, 12, 13]) },
-			{ pcm: pcm([20, 21, 22, 23, 24]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl);
-		expect(out).toHaveLength(1);
-		expect(out[0].length).toBe(9);
-		expect(Array.from(out[0])).toEqual([10, 11, 12, 13, 20, 21, 22, 23, 24]);
-	});
-
-	it("plan-vs-segments length mismatch: missing input(s) are treated as silence at the planned offset", () => {
-		// Skip the middle input → seg b's planned range renders zeros at its
-		// startSample; seg c's samples still land at offset 5 unchanged.
-		const pl = plan([seg("a", 0, 2, false), seg("b", 2, 3, false), seg("c", 5, 2, false)], {
-			totalSamples: 7,
-		});
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([1, 2]) },
-			{ pcm: null }, // middle segment's input omitted → silent
-			{ pcm: pcm([9, 10]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl);
-		expect(Array.from(out[0])).toEqual([1, 2, 0, 0, 0, 9, 10]);
-	});
-});
-
-describe("assembleConcatenatedPcm — silence / missing input", () => {
-	it("silence: true → the segment's range stays all zeros; neighbors unaffected", () => {
-		const pl = plan([seg("a", 0, 2, false), seg("b", 2, 3, true), seg("c", 5, 2, false)], {
-			totalSamples: 7,
-		});
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([1, 2]) },
-			{ pcm: pcm([100, 101, 102]) }, // would be written, but silence flag wins
-			{ pcm: pcm([9, 10]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl);
-		expect(Array.from(out[0])).toEqual([1, 2, 0, 0, 0, 9, 10]);
-	});
-
-	it("pcm: null (without silence flag) → treated as silent", () => {
-		const pl = plan([seg("a", 0, 2, false), seg("b", 2, 3, false)], { totalSamples: 5 });
-		const inputs: AudioConcatAssemblerSegmentInput[] = [{ pcm: pcm([1, 2]) }, { pcm: null }];
-		const out = assembleConcatenatedPcm(inputs, pl);
-		expect(Array.from(out[0])).toEqual([1, 2, 0, 0, 0]);
-	});
-});
-
-describe("assembleConcatenatedPcm — length clamping", () => {
-	it("short input is zero-padded at the tail; the NEXT segment still starts at its offset", () => {
-		// seg A length 5 but pcm length 2 → pad to 5; seg B starts at offset 5 unchanged.
-		const pl = plan([seg("a", 0, 5, false), seg("b", 5, 3, false)], { totalSamples: 8 });
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([100, 200]) },
-			{ pcm: pcm([9, 10, 11]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl);
-		expect(Array.from(out[0])).toEqual([100, 200, 0, 0, 0, 9, 10, 11]);
-	});
-
-	it("long input is truncated; extra samples do NOT leak into the next segment's range", () => {
-		// seg A length 3 but pcm length 6 → only the first 3 land; seg B's offset is preserved.
-		const pl = plan([seg("a", 0, 3, false), seg("b", 3, 3, false)], { totalSamples: 6 });
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([1, 2, 3, 4, 5, 6]) }, // 4,5,6 must NOT appear in output
-			{ pcm: pcm([9, 10, 11]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl);
-		expect(Array.from(out[0])).toEqual([1, 2, 3, 9, 10, 11]);
-	});
-});
-
-describe("assembleConcatenatedPcm — multi-channel", () => {
-	it("stereo: two-channel input is written into two output arrays independently per channel", () => {
-		const pl = plan([seg("a", 0, 3, false), seg("b", 3, 3, false)], {
-			channels: 2,
-			totalSamples: 6,
-		});
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([10, 11, 12], [20, 21, 22]) }, // ch0: 10..12, ch1: 20..22
-			{ pcm: pcm([100, 101, 102], [200, 201, 202]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl);
-		expect(out).toHaveLength(2);
-		expect(Array.from(out[0])).toEqual([10, 11, 12, 100, 101, 102]);
-		expect(Array.from(out[1])).toEqual([20, 21, 22, 200, 201, 202]);
-	});
-
-	it("missing channel: input.pcm has 1 channel but plan.channels is 2 → that channel is silence for the segment", () => {
-		// seg A: stereo plan, only ch0 supplied → ch1 stays zero for seg A's range;
-		// seg B: full stereo, written normally at offset 3.
-		const pl = plan([seg("a", 0, 3, false), seg("b", 3, 3, false)], {
-			channels: 2,
-			totalSamples: 6,
-		});
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([10, 11, 12]) }, // no channel 1
-			{ pcm: pcm([100, 101, 102], [200, 201, 202]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl);
-		expect(Array.from(out[0])).toEqual([10, 11, 12, 100, 101, 102]);
-		expect(Array.from(out[1])).toEqual([0, 0, 0, 200, 201, 202]);
-	});
-});
-
-// --- Boundary fades (equal-power) -------------------------------------------
-
-describe("assembleConcatenatedPcm — equal-power boundary fade", () => {
-	it("f=2: tail of seg 0 is multiplied by cos((k/f)·π/2); head of seg 1 by sin((k/f)·π/2); cos²+sin² ≈ 1 for the paired offset", () => {
-		// Two segments, each length 4. Fade f=2 → seg 0 indices [2,3) faded out,
-		// seg 1 indices [0,1) faded in. Use a non-1 value (5) so the gain is visible.
-		const pl = plan([seg("a", 0, 4, false), seg("b", 4, 4, false)], { totalSamples: 8 });
-		// Source values: seg a = [5,5,5,5], seg b = [7,7,7,7]. With no fade, output
-		// would be [5,5,5,5,7,7,7,7]. After fade:
-		//   a[2] *= cos(0·π/2)   = 1      → 5
-		//   a[3] *= cos(0.5·π/2) = √2/2   → 5·√2/2
-		//   b[0] *= sin(0·π/2)   = 0      → 0
-		//   b[1] *= sin(0.5·π/2) = √2/2   → 7·√2/2
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([5, 5, 5, 5]) },
-			{ pcm: pcm([7, 7, 7, 7]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl, { boundaryFadeSamples: 2 });
-
-		// Float32 storage round-trips `input * gain` to ~7 significant digits
-		// (mantissa = 23 bits → ~6-7 decimal). Tolerance 5e-7 (precision=6)
-		// covers the worst-case Float32 quantization around |value|≈10.
-		const sqrt2over2 = Math.sqrt(2) / 2;
-		expect(out[0][0]).toBeCloseTo(5, 6); // far-from-boundary: untouched
-		expect(out[0][1]).toBeCloseTo(5, 6);
-		expect(out[0][2]).toBeCloseTo(5 * 1, 6); // k=0 → cos(0)=1
-		expect(out[0][3]).toBeCloseTo(5 * sqrt2over2, 6); // k=1 → cos(π/4)=√2/2
-		expect(out[0][4]).toBeCloseTo(7 * 0, 6); // seg b[0] → k=0 → sin(0)=0
-		expect(out[0][5]).toBeCloseTo(7 * sqrt2over2, 6); // k=1 → sin(π/4)=√2/2
-		expect(out[0][6]).toBeCloseTo(7, 6); // outside fade region
-		expect(out[0][7]).toBeCloseTo(7, 6);
-
-		// Equal-power check on the paired offset sums: cos² + sin² = 1
-		// (kernel of the spec — perceived loudness stays flat through the join).
-		// This is pure Float64 (no Float32 storage), so tighten to 12.
-		for (let k = 0; k < 2; k++) {
-			const cos = Math.cos((k / 2) * (Math.PI / 2));
-			const sin = Math.sin((k / 2) * (Math.PI / 2));
-			expect(cos * cos + sin * sin).toBeCloseTo(1, 12);
-		}
-	});
-
-	it("no fade at the OUTER edges — first sample of seg 0 and last sample of the last segment are untouched", () => {
-		// Three segments, fade=1 between each. The very first and very last sample
-		// sit one sample OUTSIDE any fade window → unchanged.
-		const pl = plan([seg("a", 0, 3, false), seg("b", 3, 3, false), seg("c", 6, 3, false)], {
-			totalSamples: 9,
-		});
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([1, 2, 3]) },
-			{ pcm: pcm([9, 9, 9]) },
-			{ pcm: pcm([4, 5, 6]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl, { boundaryFadeSamples: 1 });
-		// cos(0)=1, sin(0)=0 — fade-OUT leaves a[2] unchanged, fade-IN zeros b[3].
-		expect(out[0][0]).toBeCloseTo(1, 6); // far outer edge
-		expect(out[0][2]).toBeCloseTo(3, 6); // inside fade-OUT, but k=0 → gain 1
-		expect(out[0][3]).toBeCloseTo(0, 6); // head of seg b, k=0 → gain 0
-		expect(out[0][5]).toBeCloseTo(9, 6); // tail of seg b, k=0 → gain 1
-		expect(out[0][6]).toBeCloseTo(0, 6); // head of seg c, k=0 → gain 0
-		expect(out[0][8]).toBeCloseTo(6, 6); // far outer edge — UNCHANGED
-	});
-
-	it("fade is applied to ALL channels of a multi-channel output", () => {
-		const pl = plan([seg("a", 0, 4, false), seg("b", 4, 4, false)], {
-			channels: 2,
-			totalSamples: 8,
-		});
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([5, 5, 5, 5], [50, 50, 50, 50]) },
-			{ pcm: pcm([7, 7, 7, 7], [70, 70, 70, 70]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl, { boundaryFadeSamples: 2 });
-		const sqrt2over2 = Math.sqrt(2) / 2;
-		// Both channels follow the same equal-power law independently.
-		// Float32-bound tolerance (see note above).
-		expect(out[0][3]).toBeCloseTo(5 * sqrt2over2, 6);
-		expect(out[0][5]).toBeCloseTo(7 * sqrt2over2, 6);
-		expect(out[1][3]).toBeCloseTo(50 * sqrt2over2, 6);
-		expect(out[1][5]).toBeCloseTo(70 * sqrt2over2, 6);
-		// Untouched outer samples on both channels.
-		expect(out[1][0]).toBeCloseTo(50, 6);
-		expect(out[1][7]).toBeCloseTo(70, 6);
-	});
-
-	it("fade is clamped to floor(sampleCount/2) of each adjacent segment — boundaryFadeSamples larger than the slot", () => {
-		// seg A length 3 → floor(3/2)=1, seg B length 3 → 1: requested f0=100 → effective f=1.
-		const pl = plan([seg("a", 0, 3, false), seg("b", 3, 3, false)], { totalSamples: 6 });
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([8, 8, 8]) },
-			{ pcm: pcm([9, 9, 9]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl, { boundaryFadeSamples: 100 });
-		// Only index 2 of seg a (tail-of-fade, k=0, cos=1) and index 3 of seg b
-		// (head-of-fade, k=0, sin=0) are affected — index 1 of seg a and index 4
-		// of seg b are well outside the f=1 fade region and must be unchanged.
-		expect(out[0][0]).toBeCloseTo(8, 6);
-		expect(out[0][1]).toBeCloseTo(8, 6); // NOT in the fade region
-		expect(out[0][2]).toBeCloseTo(8, 6); // k=0 → cos(0)=1
-		expect(out[0][3]).toBeCloseTo(0, 6); // k=0 → sin(0)=0
-		expect(out[0][4]).toBeCloseTo(9, 6); // NOT in the fade region
-		expect(out[0][5]).toBeCloseTo(9, 6);
-	});
-
-	it("fade is independently clamped per boundary when adjacent segments have different lengths", () => {
-		// seg A length 10 → floor(10/2)=5 (the binding side; seg B is length 100 → bound by A).
-		const pl = plan([seg("a", 0, 10, false), seg("b", 10, 100, false)], { totalSamples: 110 });
-		// Use 1.0 so any gain shows up verbatim.
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm(new Array(10).fill(1)) },
-			{ pcm: pcm(new Array(100).fill(1)) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl, { boundaryFadeSamples: 1000 });
-		// Effective f = min(1000, floor(10/2)=5, floor(100/2)=50) = 5.
-		// seg a tail: indices [5,10) — cos gain applied. k=0 → 1, k=4 → cos(0.8π/2)≈0.309.
-		// Float32-bound tolerance.
-		expect(out[0][5]).toBeCloseTo(Math.cos((0 / 5) * (Math.PI / 2)), 6);
-		expect(out[0][9]).toBeCloseTo(Math.cos((4 / 5) * (Math.PI / 2)), 6);
-		// seg a head: indices [0,5) — unchanged.
-		expect(out[0][0]).toBeCloseTo(1, 6);
-		expect(out[0][4]).toBeCloseTo(1, 6);
-		// seg b head: indices [10,15) — sin gain applied. k=0 → 0, k=4 → sin(0.8π/2)≈0.951.
-		expect(out[0][10]).toBeCloseTo(Math.sin((0 / 5) * (Math.PI / 2)), 6);
-		expect(out[0][14]).toBeCloseTo(Math.sin((4 / 5) * (Math.PI / 2)), 6);
-		// seg b body: indices [15,110) — unchanged.
-		expect(out[0][15]).toBeCloseTo(1, 6);
-		expect(out[0][109]).toBeCloseTo(1, 6);
-	});
-
-	it("a short adjacent segment (sampleCount < 2*f0) still gets its own contribution — only its own half is faded", () => {
-		// seg A length 10, seg B length 2. f = min(f0=5, 5, 1) = 1. Only index 1 of
-		// seg A (cos) and index 0 of seg B (sin) are touched — seg B index 1 is
-		// outside the fade and stays at the input value.
-		const pl = plan([seg("a", 0, 10, false), seg("b", 10, 2, false)], { totalSamples: 12 });
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm(new Array(10).fill(2)) },
-			{ pcm: pcm([3, 3]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl, { boundaryFadeSamples: 5 });
-		// seg a body
-		expect(out[0][0]).toBeCloseTo(2, 6);
-		expect(out[0][8]).toBeCloseTo(2, 6);
-		// seg a tail — k=0 → cos(0)=1
-		expect(out[0][9]).toBeCloseTo(2, 6);
-		// seg b head — k=0 → sin(0)=0
-		expect(out[0][10]).toBeCloseTo(0, 6);
-		// seg b body (outside fade)
-		expect(out[0][11]).toBeCloseTo(3, 6);
-	});
-});
-
-describe("assembleConcatenatedPcm — boundaryFadeSamples edge values", () => {
-	it.each<[string, AssembleOptions | undefined]>([
-		["undefined", undefined],
-		["0", { boundaryFadeSamples: 0 }],
-		["negative", { boundaryFadeSamples: -10 }],
-		["NaN", { boundaryFadeSamples: Number.NaN }],
-		["Infinity", { boundaryFadeSamples: Number.POSITIVE_INFINITY }],
-	])("boundaryFadeSamples %s → no fades (plain concat)", (_label, opts) => {
-		const pl = plan([seg("a", 0, 4, false), seg("b", 4, 4, false)], { totalSamples: 8 });
-		const inputs: AudioConcatAssemblerSegmentInput[] = [
-			{ pcm: pcm([5, 5, 5, 5]) },
-			{ pcm: pcm([7, 7, 7, 7]) },
-		];
-		const out = assembleConcatenatedPcm(inputs, pl, opts);
-		expect(Array.from(out[0])).toEqual([5, 5, 5, 5, 7, 7, 7, 7]);
-	});
-});
-
-// --- Degenerate / purity -----------------------------------------------------
-
-describe("assembleConcatenatedPcm — degenerate layouts", () => {
-	it("plan.channels = 0 → returns []", () => {
-		const pl = plan([seg("a", 0, 4, false)], { channels: 0, totalSamples: 4 });
-		const out = assembleConcatenatedPcm([{ pcm: pcm([1, 2, 3, 4]) }], pl);
-		expect(out).toEqual([]);
-	});
-
-	it("plan.totalSamples = 0 with channels=2 → returns 2 empty Float32Arrays", () => {
-		const pl = plan([], { channels: 2, totalSamples: 0 });
-		const out = assembleConcatenatedPcm([], pl);
-		expect(out).toHaveLength(2);
-		expect(out[0]).toBeInstanceOf(Float32Array);
-		expect(out[0].length).toBe(0);
-		expect(out[1]).toBeInstanceOf(Float32Array);
-		expect(out[1].length).toBe(0);
-	});
-
-	it("plan.totalSamples = 0 with channels=0 → returns [] (both guards match)", () => {
-		const pl = plan([], { channels: 0, totalSamples: 0 });
-		const out = assembleConcatenatedPcm([], pl);
-		expect(out).toEqual([]);
-	});
-
-	it("plan.totalSamples = 0 with channels=3, no segments → 3 empty Float32Arrays", () => {
-		const pl = plan([], { channels: 3, totalSamples: 0 });
-		const out = assembleConcatenatedPcm([], pl);
-		expect(out).toHaveLength(3);
-		expect(out.every((a) => a.length === 0)).toBe(true);
-	});
-
-	it("plan with segments but totalSamples = 0 → 2 empty Float32Arrays", () => {
-		// Defends against the all-zero case: even though startSample/sampleCount
-		// are integers, the output buffer is empty and no fades run.
-		const pl = plan([seg("a", 0, 0, false), seg("b", 0, 0, false)], {
-			channels: 2,
-			totalSamples: 0,
-		});
-		const out = assembleConcatenatedPcm([{ pcm: pcm([1, 2]) }, { pcm: pcm([3, 4], [5, 6]) }], pl, {
-			boundaryFadeSamples: 4,
-		});
-		expect(out).toHaveLength(2);
-		expect(out[0].length).toBe(0);
-		expect(out[1].length).toBe(0);
-	});
-});
-
-describe("assembleConcatenatedPcm — purity (does not mutate inputs)", () => {
-	it("input Float32Arrays are not modified by copy or by boundary fades", () => {
-		const pl = plan([seg("a", 0, 4, false), seg("b", 4, 4, false)], { totalSamples: 8 });
-		const srcA = f32([1, 2, 3, 4]);
-		const srcB = f32([5, 6, 7, 8]);
-		const aSnapshot = Array.from(srcA);
-		const bSnapshot = Array.from(srcB);
-
-		const inputs: AudioConcatAssemblerSegmentInput[] = [{ pcm: [srcA] }, { pcm: [srcB] }];
-		const out = assembleConcatenatedPcm(inputs, pl, { boundaryFadeSamples: 2 });
-
-		// Inputs are untouched after the call (compare snapshot to live values).
-		expect(Array.from(srcA)).toEqual(aSnapshot);
-		expect(Array.from(srcB)).toEqual(bSnapshot);
-		// The output reflects the fades (so we know we actually exercised the
-		// fade path — otherwise the purity check would be vacuous).
-		expect(out[0][3]).not.toBe(bSnapshot[3] ?? 0);
-	});
-
-	it("the segments wrapper array is not mutated in length or order", () => {
-		const pl = plan([seg("a", 0, 2, false)], { totalSamples: 2 });
-		const inputs: AudioConcatAssemblerSegmentInput[] = [{ pcm: pcm([9, 9]) }];
-		const beforeLen = inputs.length;
-		assembleConcatenatedPcm(inputs, pl);
-		expect(inputs).toHaveLength(beforeLen);
-		expect(inputs[0].pcm).not.toBeNull();
-	});
-
-	it("a shared input pcm (referenced from two segments) is read-only — both outputs see the same logical source", () => {
-		// Two segments in the plan, each pointing at the same source buffer.
-		// The assembler must not overwrite either output through the shared
-		// input reference. (The fade writes ONLY into the output buffers.)
-		const shared = f32([4, 4, 4, 4]);
-		const pl = plan([seg("a", 0, 4, false), seg("b", 4, 4, false)], { totalSamples: 8 });
-		const inputs: AudioConcatAssemblerSegmentInput[] = [{ pcm: [shared] }, { pcm: [shared] }];
-		const out = assembleConcatenatedPcm(inputs, pl, { boundaryFadeSamples: 2 });
-		// Shared source is still pristine.
-		expect(Array.from(shared)).toEqual([4, 4, 4, 4]);
-		// Fade-OUT still applied to the first segment's tail; equals 4·cos(π/4)=4·√2/2.
-		// Float32-bound tolerance.
-		const sqrt2over2 = Math.sqrt(2) / 2;
-		expect(out[0][3]).toBeCloseTo(4 * sqrt2over2, 6);
-	});
-});
diff --git a/src/lib/ai-edition/exporter/audioConcatAssembler.ts b/src/lib/ai-edition/exporter/audioConcatAssembler.ts
deleted file mode 100644
index 32ec829813..0000000000
--- a/src/lib/ai-edition/exporter/audioConcatAssembler.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-// AudioConcatAssembler: pure-logic PCM assembly for the v2 multi-asset export
-// audio track.
-//
-// ponytail: `audioConcatPlan.ts` decides WHERE each segment's audio lands in
-// the concatenated output (integer sample offsets / counts / silence flags at
-// a common sampleRate + channels). This module does the actual sample copy:
-// for every plan segment, it takes the segment's already-decoded,
-// already-resampled PLANAR PCM (one Float32Array per channel) and writes it
-// into the right offset of a single output buffer, clamping each channel to
-// the planned sampleCount (longer input → truncate; shorter input → zero-pad)
-// so a small decode over/under-run never shifts the timeline. A short
-// equal-power fade is applied at every INTERNAL segment boundary to suppress
-// clicks where two different recordings meet butt-joined — without changing
-// timing, so audio stays locked to the video (which is retimed independently).
-//
-// The plan places segments BUTT-JOINED (segment i+1 starts exactly where i
-// ends, no overlap) because `plan.totalSamples` must equal the video frame
-// count for A/V lock, so a true overlapping crossfade is not an option (it
-// would shorten the track and drift A/V). Instead we use equal-power gains:
-// fade-out gain at offset k∈[0,f) = cos((k/f)·π/2) and fade-in at the matching
-// offset = sin((k/f)·π/2). `cos² + sin² = 1` keeps perceived power even.
-//
-// Pure: no DOM, no IPC, no WebCodecs, no AudioContext — only Float32Array
-// math. Inputs are never mutated.
-
-import type { AudioConcatPlan } from "./audioConcatPlan";
-
-// One entry per plan segment (SAME order/length as `plan.segments`). `pcm` is
-// the segment's decoded audio, PLANAR (one Float32Array per channel), already
-// at `plan.sampleRate` / `plan.channels`. `null` → silent segment (renders
-// zeros — equivalent to `seg.silence === true`). The assembler clamps each
-// channel to the plan's `sampleCount`: a longer buffer is truncated, a
-// shorter one is zero-padded, so a small decode over/under-run never shifts
-// the timeline.
-export interface AudioConcatAssemblerSegmentInput {
-	pcm: Float32Array[] | null;
-}
-
-export interface AssembleOptions {
-	// Equal-power fade length (in samples) applied at each INTERNAL segment
-	// boundary to avoid clicks. Clamped per-boundary to at most
-	// `floor(sampleCount/2)` of each adjacent segment. Default 0 (no fade).
-	// Non-finite / negative values are treated as 0.
-	boundaryFadeSamples?: number;
-}
-
-// Returns `plan.channels` planar Float32Arrays, each of length `plan.totalSamples`.
-// Pure: never mutates `segments` or their `pcm` arrays.
-export function assembleConcatenatedPcm(
-	segments: AudioConcatAssemblerSegmentInput[],
-	plan: AudioConcatPlan,
-	options?: AssembleOptions,
-): Float32Array[] {
-	// Degenerate layouts — no channels to fill.
-	if (plan.channels <= 0) return [];
-	if (plan.totalSamples === 0) {
-		const empty: Float32Array[] = [];
-		for (let i = 0; i < plan.channels; i++) empty.push(new Float32Array(0));
-		return empty;
-	}
-
-	// 1) Allocate `plan.channels` output Float32Arrays (zero-filled = silence).
-	const output: Float32Array[] = [];
-	for (let c = 0; c < plan.channels; c++) {
-		output.push(new Float32Array(plan.totalSamples));
-	}
-
-	// 2) Copy each segment's PCM into its planned slot. A silent segment
-	// (per plan) or a missing/short input leaves zeros in the slot — the
-	// timeline (startSample + sampleCount) is preserved either way.
-	const segCount = plan.segments.length;
-	for (let i = 0; i < segCount; i++) {
-		const seg = plan.segments[i];
-		const start = seg.startSample;
-		const count = seg.sampleCount;
-		if (count <= 0) continue;
-		const input = segments[i];
-		if (seg.silence) continue;
-		if (!input || input.pcm == null) continue;
-
-		const src = input.pcm;
-		for (let c = 0; c < plan.channels; c++) {
-			const dst = output[c];
-			const srcCh = src[c];
-			if (!srcCh) continue; // missing channel → silence for this segment
-			const copy = count < srcCh.length ? count : srcCh.length;
-			// Bounds already enforced (start..start+count ⊂ [0, totalSamples),
-			// srcCh.length ≥ copy) — no overrun possible, no clamp needed.
-			for (let k = 0; k < copy; k++) {
-				dst[start + k] = srcCh[k];
-			}
-			// Any tail beyond `copy` (count > srcCh.length) is left at zero
-			// (the Float32Array was zero-filled at allocation).
-		}
-	}
-
-	// 3) Boundary fades (after all copies). At each INTERNAL boundary the tail
-	// of segment i is multiplied by a fade-out gain (`cos`) and the head of
-	// segment i+1 by a fade-in gain (`sin`) with matching offsets so the sum of
-	// squares is 1 — equal-power, no perceived dip. Applied to every channel
-	// (multiplication by 0 on a silent side is a harmless no-op).
-	const f0 = options?.boundaryFadeSamples ?? 0;
-	if (Number.isFinite(f0) && f0 > 0 && segCount >= 2) {
-		for (let i = 0; i < segCount - 1; i++) {
-			const cur = plan.segments[i];
-			const next = plan.segments[i + 1];
-			const f = Math.min(f0, Math.floor(cur.sampleCount / 2), Math.floor(next.sampleCount / 2));
-			if (f <= 0) continue;
-			const halfPi = Math.PI / 2;
-			for (let c = 0; c < plan.channels; c++) {
-				const dst = output[c];
-				// Fade-OUT tail of cur: k=0 → gain 1, k=f-1 → ~0.
-				const tailStart = cur.startSample + cur.sampleCount - f;
-				for (let k = 0; k < f; k++) {
-					const gain = Math.cos((k / f) * halfPi);
-					dst[tailStart + k] *= gain;
-				}
-				// Fade-IN head of next: k=0 → gain 0, k=f-1 → ~1.
-				const headStart = next.startSample;
-				for (let k = 0; k < f; k++) {
-					const gain = Math.sin((k / f) * halfPi);
-					dst[headStart + k] *= gain;
-				}
-			}
-		}
-	}
-
-	return output;
-}
diff --git a/src/lib/ai-edition/exporter/audioConcatPlan.test.ts b/src/lib/ai-edition/exporter/audioConcatPlan.test.ts
deleted file mode 100644
index 0ef6e3649b..0000000000
--- a/src/lib/ai-edition/exporter/audioConcatPlan.test.ts
+++ /dev/null
@@ -1,172 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { type AudioConcatSegmentInput, buildAudioConcatPlan } from "./audioConcatPlan";
-
-// --- Factory helpers (lean: only fields the builder reads) --------------------
-
-function seg(clipId: string, outputFrameCount: number, hasAudio: boolean): AudioConcatSegmentInput {
-	return { clipId, outputFrameCount, hasAudio };
-}
-
-// --- Defaults + layout -------------------------------------------------------
-
-describe("buildAudioConcatPlan — layout", () => {
-	it("single segment with audio: sampleCount = round(300/30*48000)=480000, silence false, totalSamples 480000", () => {
-		const plan = buildAudioConcatPlan([seg("c1", 300, true)], { frameRate: 30 });
-		expect(plan.sampleRate).toBe(48_000);
-		expect(plan.channels).toBe(2);
-		expect(plan.totalSamples).toBe(480_000);
-		expect(plan.segments).toEqual([
-			{ clipId: "c1", startSample: 0, sampleCount: 480_000, silence: false },
-		]);
-	});
-
-	it("defaults sampleRate=48000 and channels=2 when options omit them", () => {
-		const plan = buildAudioConcatPlan([seg("c1", 0, true)], { frameRate: 30 });
-		expect(plan.sampleRate).toBe(48_000);
-		expect(plan.channels).toBe(2);
-	});
-
-	it("honors custom sampleRate=44100 and channels=1 in both the plan header and sample math", () => {
-		// round(480/24 * 44100) = round(882000) = 882000 (exact integer — the
-		// sample-math assertion still confirms the custom rate is plugged in).
-		const plan = buildAudioConcatPlan([seg("c1", 480, true)], {
-			frameRate: 24,
-			sampleRate: 44_100,
-			channels: 1,
-		});
-		expect(plan.sampleRate).toBe(44_100);
-		expect(plan.channels).toBe(1);
-		expect(plan.segments[0].sampleCount).toBe(882_000);
-		expect(plan.totalSamples).toBe(882_000);
-	});
-});
-
-// --- Offsets + integer accumulation (R5) -------------------------------------
-
-describe("buildAudioConcatPlan — offsets", () => {
-	it("three audio segments: startSample[i] = sum(prior sampleCounts); totalSamples = sum(all)", () => {
-		// frameRate 60, sampleRate 48000 → sampleCount = outputFrameCount * 800.
-		const plans = buildAudioConcatPlan(
-			[seg("a", 60, true), seg("b", 30, true), seg("c", 90, true)],
-			{ frameRate: 60 },
-		);
-		expect(plans.segments.map((s) => s.startSample)).toEqual([0, 48_000, 72_000]);
-		expect(plans.segments.map((s) => s.sampleCount)).toEqual([48_000, 24_000, 72_000]);
-		expect(plans.totalSamples).toBe(48_000 + 24_000 + 72_000);
-		// cumulative-shapes equivalence for exact-integer math.
-		expect(plans.totalSamples).toBe(0 + 48_000 + 24_000 + 72_000);
-	});
-
-	it("silence padding: a hasAudio=false segment occupies its full sampleCount and shifts the next startSample", () => {
-		// frameRate 30, sampleRate 48000 → sampleCount = outputFrameCount * 1600.
-		const plans = buildAudioConcatPlan(
-			[seg("a", 30, true), seg("b", 15, false), seg("c", 30, true)],
-			{ frameRate: 30 },
-		);
-		expect(plans.segments).toEqual([
-			{ clipId: "a", startSample: 0, sampleCount: 48_000, silence: false },
-			{ clipId: "b", startSample: 48_000, sampleCount: 24_000, silence: true },
-			{ clipId: "c", startSample: 72_000, sampleCount: 48_000, silence: false },
-		]);
-		expect(plans.totalSamples).toBe(48_000 + 24_000 + 48_000);
-	});
-
-	it("mixed [audio, no-audio, audio]: offsets correct, only the middle flagged silence", () => {
-		const plans = buildAudioConcatPlan(
-			[seg("a", 30, true), seg("b", 15, false), seg("c", 30, true)],
-			{ frameRate: 30 },
-		);
-		expect(plans.segments.map((s) => s.silence)).toEqual([false, true, false]);
-		// startSample[2] is exactly startSample[1] + sampleCount[1] (no rounding
-		// shortcut) — A/V stays locked through the silence gap.
-		expect(plans.segments[2].startSample).toBe(
-			plans.segments[1].startSample + plans.segments[1].sampleCount,
-		);
-	});
-
-	it("integer accumulation / no drift (R5): startSample[i] === sum(prior sampleCounts), NOT round(cumulativeSeconds * sampleRate)", () => {
-		// frameRate 24, sampleRate 44100, frameCount 1 → round(1837.5) = 1838
-		// per segment. The fractional intermediate is the whole point — summing
-		// the rounded integers must NOT equal round(cumulativeSeconds * sr).
-		const plans = buildAudioConcatPlan(
-			[seg("s1", 1, true), seg("s2", 1, true), seg("s3", 1, true)],
-			{ frameRate: 24, sampleRate: 44_100 },
-		);
-
-		// Every output field is an integer (no half-sample leakage anywhere).
-		for (const s of plans.segments) {
-			expect(Number.isInteger(s.startSample)).toBe(true);
-			expect(Number.isInteger(s.sampleCount)).toBe(true);
-		}
-		expect(Number.isInteger(plans.totalSamples)).toBe(true);
-
-		// Each segment = 1838 samples (= round(1/24 * 44100)).
-		expect(plans.segments.map((s) => s.sampleCount)).toEqual([1838, 1838, 1838]);
-
-		// Integer accumulation: startSample[i] is the SUM of prior sampleCounts.
-		expect(plans.segments.map((s) => s.startSample)).toEqual([0, 1838, 3676]);
-		expect(plans.totalSamples).toBe(5514);
-
-		// …which DIFFERS from `round(cumulativeSeconds * sampleRate)` (the
-		// drift-prone shortcut). Document the gap explicitly so a future refactor
-		// can't accidentally swap integer accumulation for cumulative rounding.
-		const sampleRate = plans.sampleRate;
-		const frameRate = 24;
-		const cumRoundedAt = (n: number) => Math.round(((n * 1) / frameRate) * sampleRate);
-		expect(cumRoundedAt(1)).toBe(1838); // matches — boundary case
-		expect(cumRoundedAt(2)).toBe(3675); // ≠ 3676 (drift by 1)
-		expect(cumRoundedAt(3)).toBe(5513); // ≠ 5514 (drift by 1)
-	});
-});
-
-// --- Degenerate inputs --------------------------------------------------------
-
-describe("buildAudioConcatPlan — degenerate inputs", () => {
-	it("zero segments → empty segments, totalSamples 0, layout still set", () => {
-		const plan = buildAudioConcatPlan([], { frameRate: 30 });
-		expect(plan.segments).toEqual([]);
-		expect(plan.totalSamples).toBe(0);
-		expect(plan.sampleRate).toBe(48_000);
-		expect(plan.channels).toBe(2);
-	});
-
-	it("zero-length segment: outputFrameCount 0 → sampleCount 0, next startSample unchanged", () => {
-		const plan = buildAudioConcatPlan([seg("a", 30, true), seg("b", 0, true), seg("c", 30, true)], {
-			frameRate: 30,
-		});
-		expect(plan.segments).toEqual([
-			{ clipId: "a", startSample: 0, sampleCount: 48_000, silence: false },
-			{ clipId: "b", startSample: 48_000, sampleCount: 0, silence: false },
-			{ clipId: "c", startSample: 48_000, sampleCount: 48_000, silence: false },
-		]);
-		expect(plan.totalSamples).toBe(96_000);
-	});
-
-	it("frameRate = 0 guard: all sampleCounts 0, totalSamples 0, no NaN (no throw)", () => {
-		const plan = buildAudioConcatPlan(
-			[seg("a", 100, true), seg("b", 200, false), seg("c", 300, true)],
-			{ frameRate: 0 },
-		);
-		expect(plan.segments).toEqual([
-			{ clipId: "a", startSample: 0, sampleCount: 0, silence: false },
-			{ clipId: "b", startSample: 0, sampleCount: 0, silence: true },
-			{ clipId: "c", startSample: 0, sampleCount: 0, silence: false },
-		]);
-		expect(plan.totalSamples).toBe(0);
-		// Explicit NaN sweep — divide-by-zero / Infinity must NOT leak through.
-		for (const s of plan.segments) {
-			expect(Number.isNaN(s.startSample)).toBe(false);
-			expect(Number.isNaN(s.sampleCount)).toBe(false);
-		}
-		expect(Number.isNaN(plan.totalSamples)).toBe(false);
-	});
-
-	it("frameRate < 0 guard: negative frameRate treated the same as zero (degenerate, no NaN)", () => {
-		const plan = buildAudioConcatPlan([seg("a", 100, true)], { frameRate: -30 });
-		expect(plan.segments).toEqual([
-			{ clipId: "a", startSample: 0, sampleCount: 0, silence: false },
-		]);
-		expect(plan.totalSamples).toBe(0);
-		expect(Number.isNaN(plan.totalSamples)).toBe(false);
-	});
-});
diff --git a/src/lib/ai-edition/exporter/audioConcatPlan.ts b/src/lib/ai-edition/exporter/audioConcatPlan.ts
deleted file mode 100644
index 319d48d184..0000000000
--- a/src/lib/ai-edition/exporter/audioConcatPlan.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-// AudioConcatPlan: pure-logic timing for the v2 multi-asset export audio track.
-//
-// ponytail: the v1 `documentExporter` runs a single continuous source stream
-// (the primary asset), so audio "follows" video implicitly and the exporter
-// just trims/speed-stretches one buffer end-to-end. The v2 renderer walks an
-// ordered list of per-clip render segments (each drawing from its own source
-// asset), so we have to concatenate N per-segment audio buffers into one
-// output track — and the silence gaps for segments whose asset has no audio
-// must be sized so A/V never drifts. This module computes the INTEGER sample
-// accounting only; it does NOT decode, encode, resample, or touch WebCodecs
-// / AudioContext. A downstream audio encoder/mixer reads the plan and emits
-// the actual PCM.
-//
-// Integer accumulation matters (spec risk R5): each segment's audio length
-// is rounded independently from its `outputFrameCount`, then offsets are the
-// integer sum of prior rounded lengths. Never `round(cumulativeSeconds *
-// sampleRate)` — that compounds per-segment rounding error across a long
-// multi-segment timeline into audible A/V drift.
-
-const DEFAULT_SAMPLE_RATE = 48_000;
-const DEFAULT_CHANNELS = 2;
-
-// One entry per RenderPlan segment (same order). The v2 segment loop supplies
-// the output video frame count so audio can be locked 1:1 to the retimed
-// video — same SSOT the video path uses (see audioEncoder's
-// `round(frameCount / frameRate * sampleRate)` accounting).
-export interface AudioConcatSegmentInput {
-	clipId: string;
-	// OUTPUT (virtual-timeline) video frames this segment renders. Audio is
-	// sized from this so A/V never drifts — same SSOT the video path uses.
-	outputFrameCount: number;
-	// Whether this segment's asset has a usable audio track. When false, the
-	// segment contributes SILENCE for its whole output duration (keeps A/V
-	// aligned).
-	hasAudio: boolean;
-}
-
-export interface AudioConcatSegmentPlan {
-	clipId: string;
-	startSample: number; // inclusive, output samples at `sampleRate`
-	sampleCount: number; // samples this segment occupies in the concatenated output
-	silence: boolean; // true → fill with silence (asset had no audio)
-}
-
-export interface AudioConcatPlan {
-	sampleRate: number;
-	channels: number;
-	totalSamples: number; // sum of all segment sampleCounts
-	segments: AudioConcatSegmentPlan[];
-}
-
-export interface BuildAudioConcatPlanOptions {
-	frameRate: number;
-	// Common output layout, chosen up-front by the caller (spec §6.3: from the
-	// first segment with audio, or the 48 kHz stereo default). Defaulted here.
-	sampleRate?: number; // default 48000
-	channels?: number; // default 2
-}
-
-export function buildAudioConcatPlan(
-	segments: AudioConcatSegmentInput[],
-	options: BuildAudioConcatPlanOptions,
-): AudioConcatPlan {
-	const sampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE;
-	const channels = options.channels ?? DEFAULT_CHANNELS;
-
-	// Degenerate frameRate (0 or negative) → no segment can be sized without
-	// divide-by-zero / NaN. Return a plan with all-zero sample counts rather
-	// than throwing; the downstream encoder will still see a well-formed
-	// (if empty) buffer layout and the timeline is otherwise deterministic.
-	const frameRateValid = options.frameRate > 0;
-
-	const plans: AudioConcatSegmentPlan[] = [];
-	let cursor = 0;
-	for (const seg of segments) {
-		const sampleCount = frameRateValid
-			? Math.max(0, Math.round((seg.outputFrameCount / options.frameRate) * sampleRate))
-			: 0;
-		plans.push({
-			clipId: seg.clipId,
-			startSample: cursor,
-			sampleCount,
-			silence: !seg.hasAudio,
-		});
-		cursor += sampleCount;
-	}
-
-	return {
-		sampleRate,
-		channels,
-		totalSamples: cursor,
-		segments: plans,
-	};
-}
diff --git a/src/lib/ai-edition/exporter/documentExporter.test.ts b/src/lib/ai-edition/exporter/documentExporter.test.ts
index 504a25e520..e973f4bd84 100644
--- a/src/lib/ai-edition/exporter/documentExporter.test.ts
+++ b/src/lib/ai-edition/exporter/documentExporter.test.ts
@@ -2,11 +2,7 @@ import { describe, expect, it } from "vitest";
 import type { CursorRecordingData } from "@/native/contracts";
 import type { AxcutAsset, AxcutClip, AxcutDocument, AxcutTrimRange } from "../schema";
 import type { DocumentExportOptions } from "./documentExporter";
-import {
-	buildDocumentRenderPlan,
-	computeCropSchedule,
-	computeExportTrimRegions,
-} from "./documentExporter";
+import { computeCropSchedule, computeExportTrimRegions } from "./documentExporter";
 
 function clip(p: Partial<AxcutClip> & Pick<AxcutClip, "id">): AxcutClip {
 	return {
@@ -109,146 +105,3 @@ describe("computeCropSchedule", () => {
 		]);
 	});
 });
-
-describe("buildDocumentRenderPlan", () => {
-	function assetOf(p: Partial<AxcutAsset> & Pick<AxcutAsset, "id">): AxcutAsset {
-		return {
-			kind: "video",
-			label: "Asset",
-			originalPath: `/tmp/${p.id}.mp4`,
-			cameraTrack: null,
-			...p,
-		};
-	}
-
-	// Minimal document — buildDocumentRenderPlan/buildRenderPlan only read project,
-	// assets, timeline.{clips,trimRanges}, zoomRanges, annotations, legacyEditor.
-	function docOf(p: {
-		assets: AxcutAsset[];
-		clips: AxcutClip[];
-		primaryAssetId?: string;
-		legacyEditor?: Record<string, unknown> | null;
-	}): AxcutDocument {
-		return {
-			project: { primaryAssetId: p.primaryAssetId },
-			assets: p.assets,
-			timeline: { clips: p.clips, trimRanges: [] },
-			zoomRanges: [],
-			annotations: [],
-			legacyEditor: p.legacyEditor ?? null,
-		} as unknown as AxcutDocument;
-	}
-
-	const baseOptions: DocumentExportOptions = { quality: "source", format: "mp4" };
-
-	it("maps codec + frameRate and sizes output from the largest asset", () => {
-		const doc = docOf({
-			assets: [
-				assetOf({
-					id: "a",
-					durationSec: 30,
-					video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-				}),
-			],
-			clips: [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })],
-		});
-		const plan = buildDocumentRenderPlan(doc, { ...baseOptions, codec: "h265", frameRate: 30 });
-		expect(plan.output.codec).toBe("hvc1.1.6.L120.90");
-		expect(plan.output.frameRate).toBe(30);
-		expect(plan.output.width).toBe(1920);
-		expect(plan.output.height).toBe(1080);
-		expect(plan.segments).toHaveLength(1);
-	});
-
-	it("uses options.sourceWidth/Height as fallback dims when the asset has no video block", () => {
-		const doc = docOf({
-			assets: [assetOf({ id: "a", durationSec: 30 })], // no `video`
-			clips: [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })],
-		});
-		const plan = buildDocumentRenderPlan(doc, {
-			...baseOptions,
-			sourceWidth: 1280,
-			sourceHeight: 720,
-		});
-		expect(plan.segments[0].sourceWidth).toBe(1280);
-		expect(plan.segments[0].sourceHeight).toBe(720);
-	});
-
-	it("threads cursor recording + scale + theme into plan.cursor and partitions samples per segment", () => {
-		const recordingData: CursorRecordingData = {
-			version: 1,
-			provider: "native",
-			assets: [],
-			samples: [
-				{ timeMs: 100, cx: 0.5, cy: 0.5, assetId: "a" },
-				{ timeMs: 200, cx: 0.4, cy: 0.4, assetId: "b" },
-			],
-		};
-		const doc = docOf({
-			assets: [
-				assetOf({
-					id: "a",
-					durationSec: 30,
-					video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-				}),
-				assetOf({
-					id: "b",
-					durationSec: 30,
-					video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-				}),
-			],
-			clips: [
-				clip({
-					id: "c1",
-					assetId: "a",
-					sourceStartSec: 0,
-					sourceEndSec: 5,
-					timelineStartSec: 0,
-					timelineEndSec: 5,
-				}),
-				clip({
-					id: "c2",
-					assetId: "b",
-					sourceStartSec: 0,
-					sourceEndSec: 5,
-					timelineStartSec: 5,
-					timelineEndSec: 10,
-				}),
-			],
-			legacyEditor: { cursorTheme: "dark" },
-		});
-		const plan = buildDocumentRenderPlan(doc, {
-			...baseOptions,
-			cursorRecordingData: recordingData,
-			cursorScale: 1.2,
-			cursorSmoothing: 0.4,
-		});
-		expect(plan.cursor).toMatchObject({ scale: 1.2, smoothing: 0.4, theme: "dark" });
-		expect(plan.segments[0].cursorSamples.map((s) => s.timeMs)).toEqual([100]);
-		expect(plan.segments[1].cursorSamples.map((s) => s.timeMs)).toEqual([200]);
-	});
-
-	it("leaves plan.cursor null when cursor scale is unset (0)", () => {
-		const recordingData: CursorRecordingData = {
-			version: 1,
-			provider: "native",
-			assets: [],
-			samples: [{ timeMs: 0, cx: 0.5, cy: 0.5, assetId: "a" }],
-		};
-		const doc = docOf({
-			assets: [
-				assetOf({
-					id: "a",
-					durationSec: 30,
-					video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-				}),
-			],
-			clips: [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })],
-		});
-		const plan = buildDocumentRenderPlan(doc, {
-			...baseOptions,
-			cursorRecordingData: recordingData,
-		});
-		expect(plan.cursor).toBeNull();
-	});
-});
diff --git a/src/lib/ai-edition/exporter/documentExporter.ts b/src/lib/ai-edition/exporter/documentExporter.ts
index 48f8b0c5aa..351ac0ed41 100644
--- a/src/lib/ai-edition/exporter/documentExporter.ts
+++ b/src/lib/ai-edition/exporter/documentExporter.ts
@@ -1,7 +1,7 @@
-// Adapter: feeds an AxcutDocument into the existing VideoExporter / GifExporter
-// by mapping document fields → VideoExporterConfig. No rewrite of the export
-// pipeline — the existing FrameRenderer + StreamingVideoDecoder + muxer handle
-// all the rendering (annotations, zoom, blur, webcam, cursor).
+// Adapter: feeds an AxcutDocument into GifExporter. GIF is the only format
+// rendered here — MP4 goes through the native D3D exporter, which ExportDialog
+// calls directly. FrameRenderer + StreamingVideoDecoder do the rendering
+// (annotations, zoom, blur, webcam, cursor).
 //
 // ponytail: the existing exporter accepts trimRegions (removed spans in source
 // time). Two contributors are merged into them (see computeExportTrimRegions):
@@ -29,16 +29,9 @@ import {
 	GifExporter,
 	type GifFrameRate,
 	type GifSizePreset,
-	VideoExporter,
 } from "@/lib/exporter";
-import { calculateMp4ExportSettings } from "@/lib/exporter/mp4ExportSettings";
 import type { ExportProgress } from "@/lib/exporter/types";
 import type { CursorRecordingData, CursorTelemetryPoint } from "@/native/contracts";
-import {
-	type AspectRatio,
-	getAspectRatioValue,
-	getNativeAspectRatioValue,
-} from "@/utils/aspectRatioUtils";
 import {
 	captionCuesToTextRegions,
 	deriveCaptionCues,
@@ -50,18 +43,9 @@ import { type Interval, normalizeIntervals, primaryAssetDuration } from "../docu
 import type { AxcutAsset, AxcutDocument } from "../schema";
 import { resolveClipSourceEndSec } from "../timeline/clipDuration";
 import { projectRegionsToSourceTime } from "../timeline/region-ventilation";
-import { buildRenderPlan, type RenderPlan } from "./renderPlan";
 
 export type ExportVideoCodec = "h264" | "h265" | "vp9";
 
-// WebCodecs encoder strings per user-facing codec choice (F2.4). The muxer
-// derives its mp4 track family from the same string.
-const CODEC_STRINGS: Record<ExportVideoCodec, string> = {
-	h264: "avc1.640033",
-	h265: "hvc1.1.6.L120.90",
-	vp9: "vp09.00.10.08",
-};
-
 export interface DocumentExportOptions {
 	quality: ExportQuality;
 	format: ExportFormat;
@@ -165,36 +149,6 @@ function extractLegacyField<T>(
 	return fallback;
 }
 
-// Maps the dialog's DocumentExportOptions onto the v2 RenderPlan (multi-asset,
-// virtual-time effects, per-segment cursor). This is the single boundary where
-// the document + export options become the plan the segment-loop renderer will
-// consume. It runs today alongside the legacy config assembly below — the plan
-// is threaded to VideoExporter but only drives rendering once the segment loop
-// is enabled (see VideoExporterConfig.renderPlan). Cursor scale/theme come from
-// options + legacyEditor exactly as the legacy path reads them.
-export function buildDocumentRenderPlan(
-	document: AxcutDocument,
-	options: DocumentExportOptions,
-): RenderPlan {
-	const legacy = document.legacyEditor as Record<string, unknown> | null;
-	return buildRenderPlan(document, {
-		quality: options.quality,
-		frameRate: options.frameRate ?? 60,
-		codec: options.codec ?? "h264",
-		fallbackSourceWidth: options.sourceWidth,
-		fallbackSourceHeight: options.sourceHeight,
-		cursor: {
-			recordingData: options.cursorRecordingData ?? null,
-			scale: options.cursorScale ?? 0,
-			smoothing: options.cursorSmoothing,
-			motionBlur: options.cursorMotionBlur,
-			clickBounce: options.cursorClickBounce,
-			clipToBounds: options.cursorClipToBounds,
-			theme: extractLegacyField(legacy, "cursorTheme", ""),
-		},
-	});
-}
-
 export async function exportAxcutDocument(
 	document: AxcutDocument,
 	options: DocumentExportOptions,
@@ -268,24 +222,6 @@ export async function exportAxcutDocument(
 		() => createId("camfull"),
 	);
 
-	const sourceWidth = options.sourceWidth || 1920;
-	const sourceHeight = options.sourceHeight || 1080;
-	// Respect the timeline's selected aspect ratio (the whole-canvas framing set
-	// in the editor), not a hardcoded 16:9. "native" follows the source's own
-	// pixel aspect. This is a per-timeline choice, not per-clip.
-	const aspectRatio = extractLegacyField<AspectRatio>(legacy, "aspectRatio", "16:9");
-	const aspectRatioValue =
-		aspectRatio === "native"
-			? getNativeAspectRatioValue(sourceWidth, sourceHeight)
-			: getAspectRatioValue(aspectRatio);
-
-	const settings = calculateMp4ExportSettings({
-		quality: options.quality,
-		sourceWidth,
-		sourceHeight,
-		aspectRatioValue,
-	});
-
 	const cameraTrack = asset.cameraTrack;
 
 	const commonConfig = {
@@ -334,30 +270,16 @@ export async function exportAxcutDocument(
 		onProgress: options.onProgress,
 	};
 
-	if (options.format === "gif") {
-		const exporter = new GifExporter({
-			...commonConfig,
-			width: 1280,
-			height: 720,
-			frameRate: options.gifFrameRate ?? 15,
-			loop: options.gifLoop ?? true,
-			sizePreset: options.gifSizePreset ?? "medium",
-		} as unknown as ConstructorParameters<typeof GifExporter>[0]);
-		return exporter.export();
-	}
-
-	const exporter = new VideoExporter({
+	// GIF is the only format this adapter renders. MP4 goes through the native
+	// D3D exporter (`exportMultiNative`), which ExportDialog calls directly.
+	const exporter = new GifExporter({
 		...commonConfig,
-		width: settings.width,
-		height: settings.height,
-		frameRate: options.frameRate ?? 60,
-		bitrate: settings.bitrate,
-		codec: CODEC_STRINGS[options.codec ?? "h264"],
-		// v2 multi-asset plan, threaded to the exporter. Consumed only once the
-		// segment-loop path is enabled; the legacy single-asset config above still
-		// drives rendering until then.
-		renderPlan: buildDocumentRenderPlan(document, options),
-	});
+		width: 1280,
+		height: 720,
+		frameRate: options.gifFrameRate ?? 15,
+		loop: options.gifLoop ?? true,
+		sizePreset: options.gifSizePreset ?? "medium",
+	} as unknown as ConstructorParameters<typeof GifExporter>[0]);
 	return exporter.export();
 }
 
diff --git a/src/lib/ai-edition/exporter/renderPlan.test.ts b/src/lib/ai-edition/exporter/renderPlan.test.ts
deleted file mode 100644
index a77adc2249..0000000000
--- a/src/lib/ai-edition/exporter/renderPlan.test.ts
+++ /dev/null
@@ -1,942 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { AnnotationRegion, SpeedRegion, ZoomRegion } from "@/components/video-editor/types";
-import { calculateMp4ExportSettings } from "@/lib/exporter/mp4ExportSettings";
-import type { CursorRecordingData, CursorRecordingSample } from "@/native/contracts";
-import type { AxcutAsset, AxcutClip, AxcutTrimRange } from "../schema";
-import { buildRenderPlan, isIdentityFastPathEligible } from "./renderPlan";
-
-// --- Factory helpers (lean: only fields the builder reads) --------------------
-
-function asset(p: Partial<AxcutAsset> & Pick<AxcutAsset, "id">): AxcutAsset {
-	return {
-		kind: "video",
-		label: "Asset",
-		originalPath: "/tmp/asset.mp4",
-		cameraTrack: null,
-		...p,
-	};
-}
-
-function clip(p: Partial<AxcutClip> & Pick<AxcutClip, "id">): AxcutClip {
-	return {
-		assetId: "a",
-		sourceStartSec: 0,
-		sourceEndSec: 10,
-		timelineStartSec: 0,
-		timelineEndSec: 10,
-		wordRefs: [],
-		origin: "user",
-		reason: "",
-		...p,
-	};
-}
-
-function trim(p: Partial<AxcutTrimRange> & Pick<AxcutTrimRange, "id">): AxcutTrimRange {
-	return { assetId: "a", startSec: 0, endSec: 1, origin: "user", reason: "", ...p };
-}
-
-function zoom(p: Partial<ZoomRegion> & Pick<ZoomRegion, "id">): ZoomRegion {
-	return {
-		startMs: 0,
-		endMs: 1000,
-		depth: 2,
-		focus: { cx: 0.5, cy: 0.5 },
-		...p,
-	};
-}
-
-function annotation(p: Partial<AnnotationRegion> & Pick<AnnotationRegion, "id">): AnnotationRegion {
-	return {
-		startMs: 0,
-		endMs: 1000,
-		type: "text",
-		content: "hi",
-		position: { x: 50, y: 50 },
-		size: { width: 30, height: 20 },
-		style: {
-			color: "#fff",
-			backgroundColor: "transparent",
-			fontSize: 32,
-			fontFamily: "Inter",
-			fontWeight: "bold",
-			fontStyle: "normal",
-			textDecoration: "none",
-			textAlign: "center",
-		},
-		zIndex: 1,
-		...p,
-	};
-}
-
-function speed(p: Partial<SpeedRegion> & Pick<SpeedRegion, "id">): SpeedRegion {
-	return { startMs: 0, endMs: 1000, speed: 1, ...p };
-}
-
-function cursorSample(
-	p: Partial<CursorRecordingSample> & Pick<CursorRecordingSample, "timeMs">,
-): CursorRecordingSample {
-	return { cx: 0.5, cy: 0.5, ...p };
-}
-
-function cursorRecording(p: Partial<CursorRecordingData> = {}): CursorRecordingData {
-	return { version: 1, provider: "native", samples: [], assets: [], ...p };
-}
-
-// Minimal valid document for the builder — the builder only reads project,
-// assets, timeline.{clips, trimRanges}, zoomRanges, annotations, legacyEditor.
-//
-// ponytail: `zoomRegions` (with `s`) is the spec-facing key on RenderPlan and
-// what tests pass in; `zoomRanges` (without) is the schema field on the
-// document we feed the builder. Keep both names straight.
-function doc(
-	p: Partial<{
-		assets: AxcutAsset[];
-		clips: AxcutClip[];
-		trimRanges: AxcutTrimRange[];
-		zoomRegions: ZoomRegion[];
-		annotations: AnnotationRegion[];
-		legacyEditor: Record<string, unknown> | null;
-		primaryAssetId: string;
-	}> = {},
-) {
-	return {
-		project: { primaryAssetId: p.primaryAssetId },
-		assets: p.assets ?? [],
-		timeline: {
-			clips: p.clips ?? [],
-			trimRanges: p.trimRanges ?? [],
-		},
-		zoomRanges: p.zoomRegions ?? [],
-		annotations: p.annotations ?? [],
-		legacyEditor: p.legacyEditor ?? null,
-	};
-}
-
-// --- buildRenderPlan: segments ------------------------------------------------
-
-describe("buildRenderPlan — segments", () => {
-	it("single asset, identity: one segment with the expected fields and identity fast path", () => {
-		const assets = [
-			asset({
-				id: "a",
-				originalPath: "/tmp/a.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-		];
-		const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-
-		expect(plan.segments).toHaveLength(1);
-		expect(plan.segments[0]).toEqual({
-			clipId: "c1",
-			assetId: "a",
-			videoUrl: "file:///tmp/a.mp4",
-			sourceStartSec: 0,
-			sourceEndSec: 10,
-			timelineStartSec: 0,
-			timelineEndSec: 10,
-			intraTrims: [],
-			cropRegion: { x: 0, y: 0, width: 1, height: 1 },
-			sourceWidth: 1920,
-			sourceHeight: 1080,
-			camera: null,
-			cursorSamples: [],
-		});
-		expect(plan.cursor).toBeNull();
-		// Output = source for a 1920x1080 ref at 16:9 source quality → same dims.
-		expect(plan.output.width).toBe(1920);
-		expect(plan.output.height).toBe(1080);
-		expect(isIdentityFastPathEligible(plan)).toBe(true);
-	});
-
-	it("two clips across two assets: one segment per clip, each carrying its own videoUrl + dims", () => {
-		const assets = [
-			asset({
-				id: "a1",
-				originalPath: "/tmp/a1.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-			asset({
-				id: "a2",
-				originalPath: "/tmp/a2.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-		];
-		const clips = [
-			clip({
-				id: "c1",
-				assetId: "a1",
-				sourceStartSec: 0,
-				sourceEndSec: 5,
-				timelineStartSec: 0,
-				timelineEndSec: 5,
-			}),
-			clip({
-				id: "c2",
-				assetId: "a2",
-				sourceStartSec: 5,
-				sourceEndSec: 10,
-				timelineStartSec: 5,
-				timelineEndSec: 10,
-			}),
-		];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-
-		expect(plan.segments).toHaveLength(2);
-		expect(plan.segments[0]).toMatchObject({
-			clipId: "c1",
-			assetId: "a1",
-			videoUrl: "file:///tmp/a1.mp4",
-			sourceWidth: 1920,
-			sourceHeight: 1080,
-		});
-		expect(plan.segments[1]).toMatchObject({
-			clipId: "c2",
-			assetId: "a2",
-			videoUrl: "file:///tmp/a2.mp4",
-			sourceWidth: 1920,
-			sourceHeight: 1080,
-		});
-		expect(isIdentityFastPathEligible(plan)).toBe(false);
-	});
-
-	it("sorts segments by timelineStartSec regardless of input order", () => {
-		const assets = [
-			asset({
-				id: "a1",
-				originalPath: "/tmp/a1.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-			asset({
-				id: "a2",
-				originalPath: "/tmp/a2.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-		];
-		// Inserted in reverse timeline order — builder must reorder by timelineStartSec.
-		const clips = [
-			clip({
-				id: "c2",
-				assetId: "a2",
-				sourceStartSec: 5,
-				sourceEndSec: 10,
-				timelineStartSec: 5,
-				timelineEndSec: 10,
-			}),
-			clip({
-				id: "c1",
-				assetId: "a1",
-				sourceStartSec: 0,
-				sourceEndSec: 5,
-				timelineStartSec: 0,
-				timelineEndSec: 5,
-			}),
-		];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(plan.segments.map((s) => s.clipId)).toEqual(["c1", "c2"]);
-	});
-
-	it("falls back to asset.durationSec when clip.sourceEndSec is undefined", () => {
-		const assets = [
-			asset({
-				id: "a",
-				originalPath: "/tmp/a.mp4",
-				durationSec: 42,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-		];
-		const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 5, sourceEndSec: undefined })];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(plan.segments[0].sourceEndSec).toBe(42);
-	});
-
-	it("skips clips whose asset is missing (no throw, no segment)", () => {
-		const assets = [
-			asset({
-				id: "a",
-				originalPath: "/tmp/a.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-		];
-		const clips = [
-			clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 5 }),
-			clip({ id: "c2", assetId: "ghost", sourceStartSec: 5, sourceEndSec: 10 }),
-		];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(plan.segments.map((s) => s.clipId)).toEqual(["c1"]);
-	});
-});
-
-// --- buildRenderPlan: intraTrims (per-segment scoping + clamping) -------------
-
-describe("buildRenderPlan — intraTrims", () => {
-	const assets = [
-		asset({
-			id: "a",
-			originalPath: "/tmp/a.mp4",
-			durationSec: 30,
-			video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-		}),
-		asset({
-			id: "b",
-			originalPath: "/tmp/b.mp4",
-			durationSec: 30,
-			video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-		}),
-	];
-
-	it("scopes intraTrims by assetId: trims on a different asset are dropped", () => {
-		const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 20 })];
-		const trimRanges = [
-			trim({ id: "t1", assetId: "a", startSec: 5, endSec: 8 }),
-			trim({ id: "t2", assetId: "b", startSec: 5, endSec: 8 }), // different asset → ignored
-		];
-		const plan = buildRenderPlan(doc({ assets, clips, trimRanges }), { quality: "source" });
-		expect(plan.segments[0].intraTrims).toEqual([{ startSec: 5, endSec: 8 }]);
-	});
-
-	it("clamps a partly-outside trim to the clip's [start, end) window", () => {
-		const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 10, sourceEndSec: 20 })];
-		const trimRanges = [trim({ id: "t1", assetId: "a", startSec: 5, endSec: 15 })];
-		const plan = buildRenderPlan(doc({ assets, clips, trimRanges }), { quality: "source" });
-		expect(plan.segments[0].intraTrims).toEqual([{ startSec: 10, endSec: 15 }]);
-	});
-
-	it("drops a trim that is fully outside the clip's source range", () => {
-		const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 10, sourceEndSec: 20 })];
-		const trimRanges = [trim({ id: "t1", assetId: "a", startSec: 0, endSec: 5 })];
-		const plan = buildRenderPlan(doc({ assets, clips, trimRanges }), { quality: "source" });
-		expect(plan.segments[0].intraTrims).toEqual([]);
-	});
-});
-
-// --- buildRenderPlan: crop & camera -------------------------------------------
-
-describe("buildRenderPlan — crop & camera", () => {
-	it("carries an explicit clip.cropRegion through verbatim", () => {
-		const assets = [
-			asset({
-				id: "a",
-				originalPath: "/tmp/a.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-		];
-		const crop = { x: 0.25, y: 0.25, width: 0.5, height: 0.5 };
-		const clips = [
-			clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10, cropRegion: crop }),
-		];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(plan.segments[0].cropRegion).toEqual(crop);
-	});
-
-	it("defaults to the identity crop when the clip has none", () => {
-		const assets = [
-			asset({
-				id: "a",
-				originalPath: "/tmp/a.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-		];
-		const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(plan.segments[0].cropRegion).toEqual({ x: 0, y: 0, width: 1, height: 1 });
-	});
-
-	it("attaches a camera entry when the asset's cameraTrack is visible + has a sourcePath", () => {
-		const assets = [
-			asset({
-				id: "a",
-				originalPath: "/tmp/a.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-				cameraTrack: {
-					sourcePath: "/tmp/a-cam.mp4",
-					startMs: 0,
-					offsetMs: 250,
-					visible: true,
-				},
-			}),
-		];
-		const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(plan.segments[0].camera).toEqual({
-			videoUrl: "file:///tmp/a-cam.mp4",
-			offsetMs: 250,
-		});
-	});
-
-	it("omits camera when cameraTrack is invisible", () => {
-		const assets = [
-			asset({
-				id: "a",
-				originalPath: "/tmp/a.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-				cameraTrack: {
-					sourcePath: "/tmp/a-cam.mp4",
-					startMs: 0,
-					offsetMs: 0,
-					visible: false,
-				},
-			}),
-		];
-		const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(plan.segments[0].camera).toBeNull();
-	});
-
-	it("omits camera when cameraTrack is null", () => {
-		const assets = [
-			asset({
-				id: "a",
-				originalPath: "/tmp/a.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-				cameraTrack: null,
-			}),
-		];
-		const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(plan.segments[0].camera).toBeNull();
-	});
-});
-
-// --- buildRenderPlan: output sizing -------------------------------------------
-
-describe("buildRenderPlan — output sizing", () => {
-	it("sizes output from the largest-by-pixel-area segment and matches calculateMp4ExportSettings", () => {
-		const assets = [
-			asset({
-				id: "a1",
-				originalPath: "/tmp/a1.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1280, height: 720, fps: 30 },
-			}),
-			asset({
-				id: "a2",
-				originalPath: "/tmp/a2.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 3840, height: 2160, fps: 30 },
-			}),
-		];
-		const clips = [
-			clip({
-				id: "c1",
-				assetId: "a1",
-				sourceStartSec: 0,
-				sourceEndSec: 5,
-				timelineStartSec: 0,
-				timelineEndSec: 5,
-			}),
-			clip({
-				id: "c2",
-				assetId: "a2",
-				sourceStartSec: 5,
-				sourceEndSec: 10,
-				timelineStartSec: 5,
-				timelineEndSec: 10,
-			}),
-		];
-		const plan = buildRenderPlan(doc({ assets, clips, legacyEditor: { aspectRatio: "16:9" } }), {
-			quality: "source",
-		});
-		const expected = calculateMp4ExportSettings({
-			quality: "source",
-			sourceWidth: 3840,
-			sourceHeight: 2160,
-			aspectRatioValue: 16 / 9,
-		});
-		expect(plan.output.width).toBe(expected.width);
-		expect(plan.output.height).toBe(expected.height);
-		expect(plan.output.bitrate).toBe(expected.bitrate);
-		expect(plan.aspectRatioValue).toBeCloseTo(16 / 9, 6);
-	});
-
-	it("falls back to the option-provided fallback dims when there are no segments", () => {
-		const plan = buildRenderPlan(doc({ assets: [], clips: [] }), {
-			quality: "source",
-			fallbackSourceWidth: 640,
-			fallbackSourceHeight: 480,
-		});
-		const expected = calculateMp4ExportSettings({
-			quality: "source",
-			sourceWidth: 640,
-			sourceHeight: 480,
-			aspectRatioValue: 16 / 9,
-		});
-		expect(plan.output.width).toBe(expected.width);
-		expect(plan.output.height).toBe(expected.height);
-	});
-
-	it("honors frameRate + codec options", () => {
-		const assets = [
-			asset({
-				id: "a",
-				originalPath: "/tmp/a.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-		];
-		const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })];
-		const plan = buildRenderPlan(doc({ assets, clips }), {
-			quality: "source",
-			frameRate: 30,
-			codec: "h265",
-		});
-		expect(plan.output.frameRate).toBe(30);
-		expect(plan.output.codec).toBe("hvc1.1.6.L120.90");
-	});
-});
-
-// --- buildRenderPlan: effects pass-through (VIRTUAL time, NO projection) ------
-
-describe("buildRenderPlan — effects pass-through", () => {
-	const baseAssets = [
-		asset({
-			id: "a",
-			originalPath: "/tmp/a.mp4",
-			durationSec: 30,
-			video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-		}),
-	];
-	const baseClips = [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })];
-
-	it("carries zoomRanges verbatim (same ids + startMs + endMs) — no projection", () => {
-		const zoomRegions = [
-			zoom({ id: "z1", startMs: 500, endMs: 2500, depth: 3 }),
-			zoom({ id: "z2", startMs: 4000, endMs: 6000, depth: 4 }),
-		];
-		const plan = buildRenderPlan(doc({ assets: baseAssets, clips: baseClips, zoomRegions }), {
-			quality: "source",
-		});
-		expect(plan.zoomRegions).toEqual(zoomRegions);
-	});
-
-	it("carries annotations verbatim (same ids + startMs + endMs) — no projection", () => {
-		const annotations = [
-			annotation({ id: "a1", startMs: 1000, endMs: 3000 }),
-			annotation({ id: "a2", startMs: 3500, endMs: 5500 }),
-		];
-		const plan = buildRenderPlan(doc({ assets: baseAssets, clips: baseClips, annotations }), {
-			quality: "source",
-		});
-		expect(plan.annotationRegions).toEqual(annotations);
-	});
-
-	it("carries speedRegions verbatim (same ids + startMs + endMs + speed) — no projection", () => {
-		const speedRegions = [
-			speed({ id: "s1", startMs: 1500, endMs: 2500, speed: 2 }),
-			speed({ id: "s2", startMs: 4000, endMs: 5000, speed: 0.5 }),
-		];
-		const plan = buildRenderPlan(
-			doc({
-				assets: baseAssets,
-				clips: baseClips,
-				legacyEditor: { speedRegions },
-			}),
-			{ quality: "source" },
-		);
-		expect(plan.speedRegions).toEqual(speedRegions);
-	});
-
-	it("defaults speedRegions to [] when legacyEditor is null and skips speedRegions absent", () => {
-		const plan = buildRenderPlan(doc({ assets: baseAssets, clips: baseClips }), {
-			quality: "source",
-		});
-		expect(plan.speedRegions).toEqual([]);
-	});
-
-	it("reads appearance defaults from legacyEditor with the documented fallbacks", () => {
-		const plan = buildRenderPlan(doc({ assets: baseAssets, clips: baseClips }), {
-			quality: "source",
-		});
-		expect(plan.appearance).toEqual({
-			wallpaper: "",
-			padding: 50,
-			borderRadius: 0,
-			shadowIntensity: 0,
-			showBlur: false,
-			motionBlurAmount: 0,
-		});
-	});
-});
-
-// --- buildRenderPlan: cursor (per-segment, decision D1) ----------------------
-
-describe("buildRenderPlan — cursor", () => {
-	const twoAssets = [
-		asset({
-			id: "a1",
-			originalPath: "/tmp/a1.mp4",
-			durationSec: 30,
-			video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-		}),
-		asset({
-			id: "a2",
-			originalPath: "/tmp/a2.mp4",
-			durationSec: 30,
-			video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-		}),
-	];
-	const twoClips = [
-		clip({
-			id: "c1",
-			assetId: "a1",
-			sourceStartSec: 0,
-			sourceEndSec: 5,
-			timelineStartSec: 0,
-			timelineEndSec: 5,
-		}),
-		clip({
-			id: "c2",
-			assetId: "a2",
-			sourceStartSec: 5,
-			sourceEndSec: 10,
-			timelineStartSec: 5,
-			timelineEndSec: 10,
-		}),
-	];
-
-	it("partitions samples per segment by assetId — each segment gets only its asset's samples", () => {
-		const recordingData = cursorRecording({
-			samples: [
-				cursorSample({ timeMs: 100, assetId: "a1" }),
-				cursorSample({ timeMs: 200, assetId: "a2" }),
-				cursorSample({ timeMs: 300, assetId: "a1" }),
-			],
-		});
-		const plan = buildRenderPlan(doc({ assets: twoAssets, clips: twoClips }), {
-			quality: "source",
-			cursor: { recordingData, scale: 1 },
-		});
-		expect(plan.segments[0].cursorSamples.map((s) => s.timeMs)).toEqual([100, 300]);
-		expect(plan.segments[1].cursorSamples.map((s) => s.timeMs)).toEqual([200]);
-	});
-
-	it("attributes untagged samples (no assetId) to the primary asset", () => {
-		const recordingData = cursorRecording({
-			samples: [cursorSample({ timeMs: 100 }), cursorSample({ timeMs: 200, assetId: "a2" })],
-		});
-		const plan = buildRenderPlan(
-			doc({ assets: twoAssets, clips: twoClips, primaryAssetId: "a1" }),
-			{ quality: "source", cursor: { recordingData, scale: 1 } },
-		);
-		expect(plan.segments[0].cursorSamples.map((s) => s.timeMs)).toEqual([100]);
-		expect(plan.segments[1].cursorSamples.map((s) => s.timeMs)).toEqual([200]);
-	});
-
-	it("falls back to the first asset for untagged samples when primaryAssetId is unset", () => {
-		const recordingData = cursorRecording({ samples: [cursorSample({ timeMs: 100 })] });
-		const plan = buildRenderPlan(doc({ assets: twoAssets, clips: twoClips }), {
-			quality: "source",
-			cursor: { recordingData, scale: 1 },
-		});
-		expect(plan.segments[0].cursorSamples.map((s) => s.timeMs)).toEqual([100]);
-		expect(plan.segments[1].cursorSamples).toEqual([]);
-	});
-
-	it("gives a segment whose asset has no cursor data an empty samples array (no overlay)", () => {
-		const recordingData = cursorRecording({
-			samples: [cursorSample({ timeMs: 100, assetId: "a1" })],
-		});
-		const plan = buildRenderPlan(doc({ assets: twoAssets, clips: twoClips }), {
-			quality: "source",
-			cursor: { recordingData, scale: 1 },
-		});
-		expect(plan.segments[1].cursorSamples).toEqual([]);
-	});
-
-	it("builds plan.cursor (shared atlas + style) when scale > 0 and a recording is present", () => {
-		const spriteAsset = {
-			id: "cur1",
-			platform: "windows",
-			imageDataUrl: "data:,",
-			width: 16,
-			height: 16,
-			hotspotX: 0,
-			hotspotY: 0,
-		} as CursorRecordingData["assets"][number];
-		const recordingData = cursorRecording({
-			version: 2,
-			provider: "native",
-			assets: [spriteAsset],
-			samples: [cursorSample({ timeMs: 0, assetId: "a1" })],
-		});
-		const plan = buildRenderPlan(doc({ assets: twoAssets, clips: twoClips }), {
-			quality: "source",
-			cursor: {
-				recordingData,
-				scale: 1.5,
-				smoothing: 0.3,
-				motionBlur: 0.2,
-				clickBounce: 0.5,
-				clipToBounds: true,
-				theme: "dark",
-			},
-		});
-		expect(plan.cursor).toEqual({
-			version: 2,
-			provider: "native",
-			assets: [spriteAsset],
-			scale: 1.5,
-			smoothing: 0.3,
-			motionBlur: 0.2,
-			clickBounce: 0.5,
-			clipToBounds: true,
-			theme: "dark",
-		});
-	});
-
-	it("leaves plan.cursor null and carries no samples when scale is 0 (cursor disabled)", () => {
-		const recordingData = cursorRecording({
-			samples: [cursorSample({ timeMs: 0, assetId: "a1" })],
-		});
-		const plan = buildRenderPlan(doc({ assets: twoAssets, clips: twoClips }), {
-			quality: "source",
-			cursor: { recordingData, scale: 0 },
-		});
-		expect(plan.cursor).toBeNull();
-		expect(plan.segments.every((s) => s.cursorSamples.length === 0)).toBe(true);
-	});
-
-	it("leaves plan.cursor null when no recording is supplied", () => {
-		const plan = buildRenderPlan(doc({ assets: twoAssets, clips: twoClips }), {
-			quality: "source",
-			cursor: { scale: 1 },
-		});
-		expect(plan.cursor).toBeNull();
-		expect(plan.segments.every((s) => s.cursorSamples.length === 0)).toBe(true);
-	});
-});
-
-// --- buildRenderPlan: webcam layout (global, from legacyEditor) --------------
-
-describe("buildRenderPlan — webcam layout", () => {
-	const assets = [
-		asset({
-			id: "a",
-			originalPath: "/tmp/a.mp4",
-			durationSec: 30,
-			video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-		}),
-	];
-	const clips = [clip({ id: "c1", assetId: "a", sourceStartSec: 0, sourceEndSec: 10 })];
-
-	it("uses the documented defaults when legacyEditor is null", () => {
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(plan.webcam).toEqual({
-			layoutPreset: "picture-in-picture",
-			maskShape: "rectangle",
-			mirrored: false,
-			reactiveZoom: true,
-			sizePreset: 25,
-			position: null,
-		});
-	});
-
-	it("reads webcam layout/style from legacyEditor", () => {
-		const plan = buildRenderPlan(
-			doc({
-				assets,
-				clips,
-				legacyEditor: {
-					webcamLayoutPreset: "vertical-stack",
-					webcamMaskShape: "circle",
-					webcamMirrored: true,
-					webcamReactiveZoom: false,
-					webcamSizePreset: 40,
-					webcamPosition: { cx: 0.8, cy: 0.7 },
-				},
-			}),
-			{ quality: "source" },
-		);
-		expect(plan.webcam).toEqual({
-			layoutPreset: "vertical-stack",
-			maskShape: "circle",
-			mirrored: true,
-			reactiveZoom: false,
-			sizePreset: 40,
-			position: { cx: 0.8, cy: 0.7 },
-		});
-	});
-});
-
-// --- isIdentityFastPathEligible -----------------------------------------------
-
-describe("isIdentityFastPathEligible", () => {
-	function singleUntouchedAsset() {
-		return asset({
-			id: "a",
-			originalPath: "/tmp/a.mp4",
-			durationSec: 30,
-			video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-		});
-	}
-	function singleClipOn(assetId: string) {
-		return clip({ id: "c1", assetId, sourceStartSec: 0, sourceEndSec: 10 });
-	}
-
-	it("returns true for an untouched single clip whose output matches source dims", () => {
-		const assets = [singleUntouchedAsset()];
-		const clips = [singleClipOn("a")];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(isIdentityFastPathEligible(plan)).toBe(true);
-	});
-
-	it("returns false when there are 2+ segments", () => {
-		const assets = [
-			singleUntouchedAsset(),
-			asset({
-				id: "a2",
-				originalPath: "/tmp/a2.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
-			}),
-		];
-		const clips = [
-			clip({
-				id: "c1",
-				assetId: "a",
-				sourceStartSec: 0,
-				sourceEndSec: 5,
-				timelineStartSec: 0,
-				timelineEndSec: 5,
-			}),
-			clip({
-				id: "c2",
-				assetId: "a2",
-				sourceStartSec: 0,
-				sourceEndSec: 5,
-				timelineStartSec: 5,
-				timelineEndSec: 10,
-			}),
-		];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(isIdentityFastPathEligible(plan)).toBe(false);
-	});
-
-	it("returns false when the single segment has intraTrims", () => {
-		const assets = [singleUntouchedAsset()];
-		const clips = [singleClipOn("a")];
-		const trimRanges = [trim({ id: "t1", assetId: "a", startSec: 3, endSec: 5 })];
-		const plan = buildRenderPlan(doc({ assets, clips, trimRanges }), { quality: "source" });
-		expect(isIdentityFastPathEligible(plan)).toBe(false);
-	});
-
-	it("returns false when the single segment has a non-identity crop", () => {
-		const assets = [singleUntouchedAsset()];
-		const clips = [
-			clip({
-				id: "c1",
-				assetId: "a",
-				sourceStartSec: 0,
-				sourceEndSec: 10,
-				cropRegion: { x: 0.1, y: 0.1, width: 0.8, height: 0.8 },
-			}),
-		];
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "source" });
-		expect(isIdentityFastPathEligible(plan)).toBe(false);
-	});
-
-	it("returns false when any active (non-zero-length, non-1x) speedRegion is present", () => {
-		const assets = [singleUntouchedAsset()];
-		const clips = [singleClipOn("a")];
-		const plan = buildRenderPlan(
-			doc({
-				assets,
-				clips,
-				legacyEditor: { speedRegions: [speed({ id: "s1", startMs: 1000, endMs: 3000, speed: 2 })] },
-			}),
-			{ quality: "source" },
-		);
-		expect(isIdentityFastPathEligible(plan)).toBe(false);
-	});
-
-	it("treats a 1x speedRegion of any length as inactive", () => {
-		const assets = [singleUntouchedAsset()];
-		const clips = [singleClipOn("a")];
-		const plan = buildRenderPlan(
-			doc({
-				assets,
-				clips,
-				legacyEditor: {
-					speedRegions: [
-						speed({ id: "s1", startMs: 1000, endMs: 3000, speed: 1 }),
-						speed({ id: "s2", startMs: 0, endMs: 0, speed: 2 }), // zero-length → inactive
-					],
-				},
-			}),
-			{ quality: "source" },
-		);
-		expect(isIdentityFastPathEligible(plan)).toBe(true);
-	});
-
-	it("returns false when a zoomRegion is present", () => {
-		const assets = [singleUntouchedAsset()];
-		const clips = [singleClipOn("a")];
-		const plan = buildRenderPlan(doc({ assets, clips, zoomRegions: [zoom({ id: "z1" })] }), {
-			quality: "source",
-		});
-		expect(isIdentityFastPathEligible(plan)).toBe(false);
-	});
-
-	it("returns false when an annotationRegion is present", () => {
-		const assets = [singleUntouchedAsset()];
-		const clips = [singleClipOn("a")];
-		const plan = buildRenderPlan(
-			doc({ assets, clips, annotations: [annotation({ id: "ann1" })] }),
-			{ quality: "source" },
-		);
-		expect(isIdentityFastPathEligible(plan)).toBe(false);
-	});
-
-	it("returns false when output dims differ from source dims", () => {
-		const assets = [
-			asset({
-				id: "a",
-				originalPath: "/tmp/a.mp4",
-				durationSec: 30,
-				video: { codec: "h264", width: 3840, height: 2160, fps: 30 },
-			}),
-		];
-		const clips = [singleClipOn("a")];
-		// quality: "good" → output short-side 1080 at 16:9 → 1920x1080, smaller than 3840x2160.
-		const plan = buildRenderPlan(doc({ assets, clips }), { quality: "good" });
-		expect(isIdentityFastPathEligible(plan)).toBe(false);
-	});
-
-	it("returns false when an active cursor overlay covers the single segment", () => {
-		const assets = [singleUntouchedAsset()];
-		const clips = [singleClipOn("a")];
-		const recordingData = cursorRecording({
-			samples: [cursorSample({ timeMs: 0, assetId: "a" })],
-		});
-		const plan = buildRenderPlan(doc({ assets, clips }), {
-			quality: "source",
-			cursor: { recordingData, scale: 1 },
-		});
-		expect(plan.segments[0].cursorSamples.length).toBeGreaterThan(0);
-		expect(isIdentityFastPathEligible(plan)).toBe(false);
-	});
-
-	it("stays eligible when a cursor recording exists but cursor is disabled (scale 0)", () => {
-		const assets = [singleUntouchedAsset()];
-		const clips = [singleClipOn("a")];
-		const recordingData = cursorRecording({
-			samples: [cursorSample({ timeMs: 0, assetId: "a" })],
-		});
-		const plan = buildRenderPlan(doc({ assets, clips }), {
-			quality: "source",
-			cursor: { recordingData, scale: 0 },
-		});
-		expect(isIdentityFastPathEligible(plan)).toBe(true);
-	});
-});
diff --git a/src/lib/ai-edition/exporter/renderPlan.ts b/src/lib/ai-edition/exporter/renderPlan.ts
deleted file mode 100644
index 662853c922..0000000000
--- a/src/lib/ai-edition/exporter/renderPlan.ts
+++ /dev/null
@@ -1,435 +0,0 @@
-// RenderPlan: the v2 multi-asset export pipeline's pure-logic data model.
-//
-// ponytail: today `documentExporter` plays a single continuous source stream
-// (the primary asset) and projects timeline-authored effects (zoom / annotation
-// / speed) onto each frame's *source* time, so any clip that points at a
-// different asset is silently dropped. The v2 renderer decodes one segment at
-// a time, so effects stay keyed in VIRTUAL (output) time and the plan just
-// carries an ordered list of per-clip render segments — each with its own
-// source stream and intra-clip cuts — plus the output framing and the
-// pass-through effect arrays.
-//
-// This module is the foundation: a pure (no DOM, no IPC, no side effects)
-// builder + a small `isIdentityFastPathEligible` helper the renderer can use
-// to skip re-encode-worthy work for untouched single-clip projects.
-
-import { toFileUrl } from "@/components/video-editor/projectPersistence";
-import type {
-	AnnotationRegion,
-	CropRegion,
-	SpeedRegion,
-	WebcamLayoutPreset,
-	WebcamMaskShape,
-	WebcamSizePreset,
-	ZoomRegion,
-} from "@/components/video-editor/types";
-import { calculateMp4ExportSettings } from "@/lib/exporter/mp4ExportSettings";
-import type { ExportQuality } from "@/lib/exporter/types";
-import type {
-	CursorProviderKind,
-	CursorRecordingData,
-	CursorRecordingSample,
-	NativeCursorAsset,
-} from "@/native/contracts";
-import {
-	type AspectRatio,
-	getAspectRatioValue,
-	getNativeAspectRatioValue,
-} from "@/utils/aspectRatioUtils";
-import {
-	captionCuesToTextRegions,
-	deriveCaptionCues,
-	getCaptionSettings,
-	getCaptionTranslations,
-} from "../captions";
-import { type Interval, normalizeIntervals } from "../document/timeline";
-import type { AxcutDocument } from "../schema";
-import { resolveClipSourceEndSec } from "../timeline/clipDuration";
-
-export type ExportVideoCodec = "h264" | "h265" | "vp9";
-
-// WebCodecs encoder strings per user-facing codec choice. The muxer derives
-// its mp4 track family from the same string.
-const CODEC_STRINGS: Record<ExportVideoCodec, string> = {
-	h264: "avc1.640033",
-	h265: "hvc1.1.6.L120.90",
-	vp9: "vp09.00.10.08",
-};
-
-const IDENTITY_CROP: CropRegion = { x: 0, y: 0, width: 1, height: 1 };
-
-const DEFAULT_FRAME_RATE = 60;
-const DEFAULT_FALLBACK_SOURCE_WIDTH = 1920;
-const DEFAULT_FALLBACK_SOURCE_HEIGHT = 1080;
-
-// ponytail: one render segment = one source clip fed into the decoder +
-// frame loop. The renderer iterates these in order; the segment loop tracks a
-// running output/virtual-time cursor so effects (passed through separately,
-// keyed in virtual ms) land on the right frames regardless of which asset
-// each clip draws from.
-export interface RenderSegment {
-	clipId: string;
-	assetId: string;
-	videoUrl: string;
-	sourceStartSec: number;
-	sourceEndSec: number;
-	// The clip's position on the (1:1-with-source, pre-speed) virtual timeline.
-	// Timeline-authored effects (zoom/annotation/speed) are projected onto this
-	// segment's source time through [timelineStart,timelineEnd)↔[sourceStart,…).
-	timelineStartSec: number;
-	timelineEndSec: number;
-	// Cuts INSIDE this clip, scoped per segment (unlike today's single global
-	// complement in `computeExportTrimRegions`). Pre-merged + clamped via
-	// `normalizeIntervals` so the renderer can drop straight in.
-	intraTrims: Interval[];
-	cropRegion: CropRegion;
-	sourceWidth: number;
-	sourceHeight: number;
-	// Camera (webcam) attached to this segment's asset, when present and
-	// visible. The renderer treats it as a derived stream like the existing
-	// exporter does — no per-clip stitching beyond what `cameraTrack.offsetMs`
-	// already encodes.
-	camera: { videoUrl: string; offsetMs: number } | null;
-	// Native-cursor telemetry for THIS segment's asset only (decision D1 —
-	// per-segment cursor). `CursorRecordingSample.assetId` already tags each
-	// sample with its recording, so the plan partitions the shared recording by
-	// `assetId`; samples with no tag fall back to the primary asset (older
-	// single-asset recordings). `timeMs` stays in the asset's own source time —
-	// the renderer matches it against each frame's source time inside this
-	// segment's window. Empty when the asset has no cursor data (§6.4 / risk R3):
-	// that segment renders with no cursor overlay, which is correct, not a gap.
-	cursorSamples: CursorRecordingSample[];
-}
-
-export interface RenderPlanOutput {
-	width: number;
-	height: number;
-	frameRate: number;
-	bitrate: number;
-	codec: string;
-}
-
-export interface RenderPlanAppearance {
-	wallpaper: string;
-	padding: number;
-	borderRadius: number;
-	shadowIntensity: number;
-	showBlur: boolean;
-	motionBlurAmount: number;
-}
-
-// Plan-level cursor: the SHARED parts of a native-cursor render — the sprite
-// atlas (`assets`) and the style knobs — held once for the whole export. The
-// time-varying samples live per segment on `RenderSegment.cursorSamples`
-// (partitioned by asset). `null` when the export has no cursor recording, or
-// cursor rendering is disabled (`scale <= 0`).
-export interface RenderPlanCursor {
-	version: number;
-	provider: CursorProviderKind;
-	assets: NativeCursorAsset[];
-	scale: number;
-	smoothing?: number;
-	motionBlur?: number;
-	clickBounce?: number;
-	clipToBounds?: boolean;
-	theme?: string;
-}
-
-// Global webcam layout/style (from legacyEditor) shared by every segment. The
-// per-segment webcam SOURCE (file + offset) lives on `RenderSegment.camera`; a
-// segment renders a webcam overlay only when its asset has a camera track.
-export interface RenderPlanWebcam {
-	layoutPreset: WebcamLayoutPreset;
-	maskShape: WebcamMaskShape;
-	mirrored: boolean;
-	reactiveZoom: boolean;
-	sizePreset: WebcamSizePreset;
-	position: { cx: number; cy: number } | null;
-}
-
-export interface RenderPlan {
-	output: RenderPlanOutput;
-	aspectRatioValue: number;
-	// Timeline order = output order. Sorted by `timelineStartSec` ascending so
-	// the renderer can walk segments and effects (which are keyed in virtual
-	// ms) in a single forward pass.
-	segments: RenderSegment[];
-	// VIRTUAL (output) time. Direct pass-through of the document's regions with
-	// NO projection — the segment loop already tracks the virtual-time cursor
-	// that today required `projectRegionsToSourceTime`.
-	zoomRegions: ZoomRegion[];
-	annotationRegions: AnnotationRegion[];
-	speedRegions: SpeedRegion[];
-	appearance: RenderPlanAppearance;
-	// Shared cursor style + sprite atlas (per-segment samples live on each
-	// segment). `null` when there is no recording or cursor is disabled.
-	cursor: RenderPlanCursor | null;
-	// Shared webcam layout/style (per-segment webcam source is on the segment).
-	webcam: RenderPlanWebcam;
-}
-
-export interface BuildRenderPlanCursorOptions {
-	recordingData?: CursorRecordingData | null;
-	scale?: number;
-	smoothing?: number;
-	motionBlur?: number;
-	clickBounce?: number;
-	clipToBounds?: boolean;
-	theme?: string;
-}
-
-export interface BuildRenderPlanOptions {
-	quality: ExportQuality;
-	frameRate?: number;
-	codec?: ExportVideoCodec;
-	fallbackSourceWidth?: number;
-	fallbackSourceHeight?: number;
-	// Cursor recording + style, supplied by the caller (ExportDialog) — the
-	// document/asset schema does not persist cursor telemetry. Omit for no cursor.
-	cursor?: BuildRenderPlanCursorOptions;
-}
-
-function extractLegacyField<T>(
-	legacy: Record<string, unknown> | null,
-	key: string,
-	fallback: T,
-): T {
-	if (legacy && typeof legacy[key] === typeof fallback) {
-		return legacy[key] as T;
-	}
-	return fallback;
-}
-
-// Stable, clone-only sort — never mutates the document's clips array. JS's
-// `Array.prototype.sort` is stable per ECMA-262 since ES2019, so identical
-// `timelineStartSec` preserves insertion order.
-function sortClipsByTimelineStart<T extends { timelineStartSec: number }>(clips: T[]): T[] {
-	return [...clips].sort((a, b) => a.timelineStartSec - b.timelineStartSec);
-}
-
-function buildIntraTrims(
-	document: AxcutDocument,
-	clip: AxcutDocument["timeline"]["clips"][number],
-	sourceStartSec: number,
-	sourceEndSec: number,
-): Interval[] {
-	const intersected: Interval[] = [];
-	for (const trim of document.timeline.trimRanges) {
-		if (trim.assetId !== clip.assetId) continue;
-		intersected.push({
-			startSec: Math.max(trim.startSec, sourceStartSec),
-			endSec: Math.min(trim.endSec, sourceEndSec),
-		});
-	}
-	return normalizeIntervals(sourceEndSec, intersected);
-}
-
-// Native-cursor samples belonging to one asset (decision D1 — per-segment
-// cursor). A sample with no `assetId` predates multi-asset cursor tagging, so it
-// belongs to the primary asset — attributing it there keeps single-asset
-// projects rendering their cursor exactly as before.
-function cursorSamplesForAsset(
-	recordingData: CursorRecordingData | null | undefined,
-	assetId: string,
-	primaryAssetId: string | undefined,
-): CursorRecordingSample[] {
-	if (!recordingData) return [];
-	return recordingData.samples.filter((s) => (s.assetId ?? primaryAssetId) === assetId);
-}
-
-function pickReferenceDimensions(
-	segments: RenderSegment[],
-	fallbackWidth: number,
-	fallbackHeight: number,
-): { width: number; height: number } {
-	if (segments.length === 0) {
-		return { width: fallbackWidth, height: fallbackHeight };
-	}
-	let bestArea = -1;
-	let best: { width: number; height: number } = { width: fallbackWidth, height: fallbackHeight };
-	for (const segment of segments) {
-		const area = segment.sourceWidth * segment.sourceHeight;
-		if (area > bestArea) {
-			bestArea = area;
-			best = { width: segment.sourceWidth, height: segment.sourceHeight };
-		}
-	}
-	return best;
-}
-
-export function buildRenderPlan(
-	document: AxcutDocument,
-	options: BuildRenderPlanOptions,
-): RenderPlan {
-	const fallbackWidth = options.fallbackSourceWidth ?? DEFAULT_FALLBACK_SOURCE_WIDTH;
-	const fallbackHeight = options.fallbackSourceHeight ?? DEFAULT_FALLBACK_SOURCE_HEIGHT;
-	const codec: ExportVideoCodec = options.codec ?? "h264";
-	const frameRate = options.frameRate ?? DEFAULT_FRAME_RATE;
-
-	// Primary asset id anchors untagged cursor samples (see cursorSamplesForAsset).
-	const primaryAssetId = document.project.primaryAssetId ?? document.assets[0]?.id;
-	// Cursor is only rendered when scaled up (matches the existing exporter's
-	// `hasNativeCursorOverlay = cursorScale > 0`). When disabled, carry no samples
-	// and leave `plan.cursor` null so the identity fast path stays available.
-	const cursorScale = options.cursor?.scale ?? 0;
-	const cursorRecording = cursorScale > 0 ? (options.cursor?.recordingData ?? null) : null;
-
-	// --- Segments ---
-	const sortedClips = sortClipsByTimelineStart(document.timeline.clips);
-	const segments: RenderSegment[] = [];
-	for (const clip of sortedClips) {
-		const asset = document.assets.find((a) => a.id === clip.assetId);
-		if (!asset) continue; // orphan clip — can't render, skip silently (matches today).
-
-		const sourceStartSec = clip.sourceStartSec;
-		const sourceEndSec = resolveClipSourceEndSec(clip, asset);
-		const sourceWidth = asset.video?.width || fallbackWidth || DEFAULT_FALLBACK_SOURCE_WIDTH;
-		const sourceHeight = asset.video?.height || fallbackHeight || DEFAULT_FALLBACK_SOURCE_HEIGHT;
-		const cameraTrack = asset.cameraTrack;
-		const camera =
-			cameraTrack && cameraTrack.visible && cameraTrack.sourcePath
-				? { videoUrl: toFileUrl(cameraTrack.sourcePath), offsetMs: cameraTrack.offsetMs }
-				: null;
-
-		segments.push({
-			clipId: clip.id,
-			assetId: asset.id,
-			videoUrl: toFileUrl(asset.originalPath),
-			sourceStartSec,
-			sourceEndSec,
-			timelineStartSec: clip.timelineStartSec,
-			timelineEndSec: clip.timelineEndSec,
-			intraTrims: buildIntraTrims(document, clip, sourceStartSec, sourceEndSec),
-			cropRegion: clip.cropRegion ?? IDENTITY_CROP,
-			sourceWidth,
-			sourceHeight,
-			camera,
-			cursorSamples: cursorSamplesForAsset(cursorRecording, asset.id, primaryAssetId),
-		});
-	}
-
-	// --- Output sizing ---
-	const ref = pickReferenceDimensions(segments, fallbackWidth, fallbackHeight);
-	const legacy = document.legacyEditor as Record<string, unknown> | null;
-	const aspectRatio = extractLegacyField<AspectRatio>(legacy, "aspectRatio", "16:9");
-	const aspectRatioValue =
-		aspectRatio === "native"
-			? getNativeAspectRatioValue(ref.width, ref.height)
-			: getAspectRatioValue(aspectRatio);
-	const settings = calculateMp4ExportSettings({
-		quality: options.quality,
-		sourceWidth: ref.width,
-		sourceHeight: ref.height,
-		aspectRatioValue,
-	});
-
-	// --- Effects (virtual time, pass-through, NO projection) ---
-	const zoomRegions = document.zoomRanges as unknown as ZoomRegion[];
-	// Captions are derived from the transcript and joined to the annotations here,
-	// because they render through the same text path. They must be part of the plan
-	// (and not only of the legacy config) or the segment-loop renderer would export
-	// a caption-less file — and `isIdentityFastPathEligible` would happily
-	// stream-copy a video whose captions never got drawn.
-	const captionSettings = getCaptionSettings(document);
-	const annotationRegions = [
-		...(document.annotations as unknown as AnnotationRegion[]),
-		...captionCuesToTextRegions(
-			deriveCaptionCues(document, captionSettings, getCaptionTranslations(document)),
-			captionSettings,
-		),
-	];
-	const speedRegions = extractLegacyField<SpeedRegion[]>(legacy, "speedRegions", []);
-
-	// --- Appearance ---
-	const appearance: RenderPlanAppearance = {
-		wallpaper: extractLegacyField(legacy, "wallpaper", ""),
-		padding: extractLegacyField(legacy, "padding", 50),
-		borderRadius: extractLegacyField(legacy, "borderRadius", 0),
-		shadowIntensity: extractLegacyField(legacy, "shadowIntensity", 0),
-		showBlur: extractLegacyField(legacy, "showBlur", false),
-		motionBlurAmount: extractLegacyField(legacy, "motionBlurAmount", 0),
-	};
-
-	// --- Cursor (shared atlas + style; per-segment samples set above) ---
-	const cursor: RenderPlanCursor | null = cursorRecording
-		? {
-				version: cursorRecording.version,
-				provider: cursorRecording.provider,
-				assets: cursorRecording.assets,
-				scale: cursorScale,
-				smoothing: options.cursor?.smoothing,
-				motionBlur: options.cursor?.motionBlur,
-				clickBounce: options.cursor?.clickBounce,
-				clipToBounds: options.cursor?.clipToBounds,
-				theme: options.cursor?.theme,
-			}
-		: null;
-
-	// --- Webcam (global layout/style, read from legacyEditor exactly as the
-	// legacy exporter does; per-segment source lives on segment.camera) ---
-	const webcam: RenderPlanWebcam = {
-		layoutPreset: extractLegacyField<string>(
-			legacy,
-			"webcamLayoutPreset",
-			"picture-in-picture",
-		) as WebcamLayoutPreset,
-		maskShape: extractLegacyField<string>(
-			legacy,
-			"webcamMaskShape",
-			"rectangle",
-		) as WebcamMaskShape,
-		mirrored: extractLegacyField(legacy, "webcamMirrored", false),
-		reactiveZoom: extractLegacyField(legacy, "webcamReactiveZoom", true),
-		sizePreset: extractLegacyField(legacy, "webcamSizePreset", 25),
-		position: extractLegacyField<{ cx: number; cy: number } | null>(legacy, "webcamPosition", null),
-	};
-
-	return {
-		output: {
-			width: settings.width,
-			height: settings.height,
-			frameRate,
-			bitrate: settings.bitrate,
-			codec: CODEC_STRINGS[codec],
-		},
-		aspectRatioValue,
-		segments,
-		zoomRegions,
-		annotationRegions,
-		speedRegions,
-		appearance,
-		cursor,
-		webcam,
-	};
-}
-
-function isIdentityCrop(region: CropRegion): boolean {
-	return region.x === 0 && region.y === 0 && region.width === 1 && region.height === 1;
-}
-
-// ponytail: when the only segment needs no re-encode-worthy effects AND the
-// output frame is the source frame (1:1, no aspect re-framing, no scaling),
-// the renderer can take a stream-copy fast path (remux-only) instead of a
-// full decode → composite → encode round trip.
-export function isIdentityFastPathEligible(plan: RenderPlan): boolean {
-	if (plan.segments.length !== 1) return false;
-	const segment = plan.segments[0];
-	if (segment.intraTrims.length !== 0) return false;
-	if (!isIdentityCrop(segment.cropRegion)) return false;
-	if (plan.zoomRegions.length !== 0) return false;
-	if (plan.annotationRegions.length !== 0) return false;
-	// An active cursor overlay composites pixels → no stream-copy.
-	if (plan.cursor && segment.cursorSamples.length > 0) return false;
-
-	for (const region of plan.speedRegions) {
-		const duration = region.endMs - region.startMs;
-		if (duration > 0.0001 && Math.abs(region.speed - 1) > 0.0001) {
-			return false;
-		}
-	}
-
-	if (plan.output.width !== segment.sourceWidth) return false;
-	if (plan.output.height !== segment.sourceHeight) return false;
-
-	return true;
-}
diff --git a/src/lib/ai-edition/store/zoomSuggestions.test.ts b/src/lib/ai-edition/store/zoomSuggestions.test.ts
deleted file mode 100644
index 294d2dc481..0000000000
--- a/src/lib/ai-edition/store/zoomSuggestions.test.ts
+++ /dev/null
@@ -1,116 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { type AxcutDocument, createEmptyDocument, documentSchema } from "../schema";
-import { suggestZoomRegions } from "./zoomSuggestions";
-
-function fixtureDocument(overrides: Partial<AxcutDocument> = {}): AxcutDocument {
-	const base = createEmptyDocument({ title: "Test", projectId: "proj_zoom" });
-	return documentSchema.parse({
-		...base,
-		project: { ...base.project, primaryAssetId: "asset_1" },
-		assets: [
-			{
-				id: "asset_1",
-				kind: "video",
-				label: "Recording",
-				originalPath: "C:/videos/rec.mp4",
-				durationSec: 60,
-			},
-		],
-		transcripts: [
-			{
-				assetId: "asset_1",
-				language: "en",
-				segments: [
-					// Long speech — should produce a suggestion.
-					{ id: "seg_1", kind: "speech", startSec: 0, endSec: 10, text: "Intro…", wordIds: [] },
-					// Silence — ignored.
-					{ id: "seg_2", kind: "silence", startSec: 10, endSec: 20, text: "", wordIds: [] },
-					// Too short — ignored.
-					{ id: "seg_3", kind: "speech", startSec: 20, endSec: 22, text: "Uh", wordIds: [] },
-					// Long speech — second suggestion.
-					{
-						id: "seg_4",
-						kind: "speech",
-						startSec: 30,
-						endSec: 40,
-						text: "Deep dive…",
-						wordIds: [],
-					},
-				],
-				words: [],
-			},
-		],
-		timeline: {
-			...base.timeline,
-			clips: [
-				{
-					id: "clip_1",
-					assetId: "asset_1",
-					sourceStartSec: 0,
-					sourceEndSec: 60,
-					timelineStartSec: 0,
-					timelineEndSec: 60,
-					wordRefs: [],
-					origin: "user",
-					reason: "",
-				},
-			],
-		},
-		...overrides,
-	});
-}
-
-describe("suggestZoomRegions", () => {
-	it("proposes auto zoom regions over sustained speech segments", () => {
-		const suggestions = suggestZoomRegions(fixtureDocument());
-		expect(suggestions).toHaveLength(2);
-		expect(suggestions[0]).toMatchObject({
-			depth: 2,
-			focusMode: "auto",
-			source: "auto",
-		});
-		// Padded 0.4s inside the 0–10s segment, mapped 1:1 (single full clip).
-		expect(suggestions[0].startMs).toBe(400);
-		expect(suggestions[0].endMs).toBe(9600);
-		expect(suggestions[1].startMs).toBe(30400);
-	});
-
-	it("skips segments that overlap existing zoom ranges", () => {
-		const doc = fixtureDocument();
-		const withZoom = {
-			...doc,
-			zoomRanges: [
-				{
-					id: "zoom_existing",
-					startMs: 0,
-					endMs: 12000,
-					depth: 3 as const,
-					focus: { cx: 0.5, cy: 0.5 },
-				},
-			] as AxcutDocument["zoomRanges"],
-		};
-		const suggestions = suggestZoomRegions(withZoom);
-		expect(suggestions).toHaveLength(1);
-		expect(suggestions[0].startMs).toBe(30400);
-	});
-
-	it("returns nothing without a transcript", () => {
-		const doc = { ...fixtureDocument(), transcripts: [], transcript: null };
-		expect(suggestZoomRegions(doc)).toEqual([]);
-	});
-
-	it("skips speech that was cut out of the timeline", () => {
-		const doc = fixtureDocument();
-		// Timeline keeps only 0–20s of source: the 30–40s speech is gone.
-		const trimmed = {
-			...doc,
-			timeline: {
-				...doc.timeline,
-				clips: [{ ...doc.timeline.clips[0], sourceEndSec: 20, timelineEndSec: 20 }],
-			},
-		};
-		const suggestions = suggestZoomRegions(trimmed);
-		expect(suggestions).toHaveLength(1);
-		expect(suggestions[0].startMs).toBe(400);
-	});
-});
diff --git a/src/lib/ai-edition/store/zoomSuggestions.ts b/src/lib/ai-edition/store/zoomSuggestions.ts
deleted file mode 100644
index 83090b0986..0000000000
--- a/src/lib/ai-edition/store/zoomSuggestions.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-// F2.1 — auto-zoom "wand" suggestions. Scans the transcript for sustained
-// speech segments (the silence heuristic in reverse: anything the transcriber
-// didn't mark as silence is where the speaker is explaining something) and
-// proposes zoom regions covering them. Pure — the Bottombar Magic button
-// applies the result via saveDocument.
-
-import { createId } from "../document/ids";
-import type { AxcutDocument, AxcutZoomRegion } from "../schema";
-import { locateSourcePosition } from "../timeline/virtual-preview";
-
-// A speech segment must run at least this long to justify a zoom-in.
-const MIN_SPEECH_SEC = 4;
-// Don't flood the timeline — the user can re-run after accepting/deleting.
-const MAX_SUGGESTIONS = 6;
-// Trim the zoom slightly inside the segment so the zoom-in lands after the
-// speaker starts and releases before they stop.
-const EDGE_PADDING_SEC = 0.4;
-
-function overlapsExisting(
-	startMs: number,
-	endMs: number,
-	existing: Array<{ startMs: number; endMs: number }>,
-): boolean {
-	return existing.some((z) => startMs < z.endMs && endMs > z.startMs);
-}
-
-export function suggestZoomRegions(document: AxcutDocument): AxcutZoomRegion[] {
-	const primaryAssetId = document.project.primaryAssetId ?? document.assets[0]?.id;
-	if (!primaryAssetId) return [];
-	const transcript =
-		document.transcripts.find((t) => t.assetId === primaryAssetId) ??
-		(document.transcript?.assetId === primaryAssetId ? document.transcript : null);
-	if (!transcript) return [];
-
-	const clips = document.timeline.clips;
-	const suggestions: AxcutZoomRegion[] = [];
-	const occupied: Array<{ startMs: number; endMs: number }> = document.zoomRanges.map((z) => ({
-		startMs: z.startMs,
-		endMs: z.endMs,
-	}));
-
-	for (const segment of transcript.segments) {
-		if (suggestions.length >= MAX_SUGGESTIONS) break;
-		if (segment.kind !== "speech") continue;
-		if (segment.endSec - segment.startSec < MIN_SPEECH_SEC) continue;
-
-		// Map source time → timeline time through the clip layout; segments
-		// that were cut out of the timeline are skipped entirely.
-		const start = locateSourcePosition(clips, segment.startSec + EDGE_PADDING_SEC, primaryAssetId);
-		const end = locateSourcePosition(clips, segment.endSec - EDGE_PADDING_SEC, primaryAssetId);
-		if (!start || !end) continue;
-		const startMs = Math.round(start.virtualTimeSec * 1000);
-		const endMs = Math.round(end.virtualTimeSec * 1000);
-		if (endMs - startMs < (MIN_SPEECH_SEC - 2 * EDGE_PADDING_SEC) * 1000) continue;
-		if (overlapsExisting(startMs, endMs, occupied)) continue;
-
-		const region: AxcutZoomRegion = {
-			id: createId("zoom"),
-			startMs,
-			endMs,
-			depth: 2,
-			focus: { cx: 0.5, cy: 0.5 },
-			focusMode: "auto",
-			source: "auto",
-		};
-		suggestions.push(region);
-		occupied.push({ startMs, endMs });
-	}
-
-	return suggestions;
-}
diff --git a/src/lib/exporter/asyncVideoFrameQueue.ts b/src/lib/exporter/asyncVideoFrameQueue.ts
deleted file mode 100644
index 4cab191811..0000000000
--- a/src/lib/exporter/asyncVideoFrameQueue.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-type PendingConsumer = {
-	resolve: (frame: VideoFrame | null) => void;
-	reject: (error: Error) => void;
-};
-
-export class AsyncVideoFrameQueue {
-	private frames: VideoFrame[] = [];
-	private consumers: PendingConsumer[] = [];
-	private error: Error | null = null;
-	private closed = false;
-
-	get length() {
-		return this.frames.length;
-	}
-
-	enqueue(frame: VideoFrame) {
-		if (this.closed) {
-			frame.close();
-			return;
-		}
-
-		const consumer = this.consumers.shift();
-		if (consumer) {
-			consumer.resolve(frame);
-			return;
-		}
-
-		this.frames.push(frame);
-	}
-
-	fail(error: Error) {
-		this.error = error;
-		this.closed = true;
-		const consumers = this.consumers.splice(0);
-		for (const consumer of consumers) {
-			consumer.reject(error);
-		}
-		for (const frame of this.frames) {
-			frame.close();
-		}
-		this.frames = [];
-	}
-
-	close() {
-		this.closed = true;
-		const consumers = this.consumers.splice(0);
-		for (const consumer of consumers) {
-			consumer.resolve(null);
-		}
-	}
-
-	async dequeue(): Promise<VideoFrame | null> {
-		if (this.error) {
-			throw this.error;
-		}
-
-		if (this.frames.length > 0) {
-			return this.frames.shift() ?? null;
-		}
-
-		if (this.closed) {
-			return null;
-		}
-
-		return await new Promise<VideoFrame | null>((resolve, reject) => {
-			this.consumers.push({ resolve, reject });
-		});
-	}
-
-	destroy() {
-		this.close();
-		for (const frame of this.frames) {
-			frame.close();
-		}
-		this.frames = [];
-	}
-}
diff --git a/src/lib/exporter/audioEncoder.test.ts b/src/lib/exporter/audioEncoder.test.ts
deleted file mode 100644
index 0fb3708c5a..0000000000
--- a/src/lib/exporter/audioEncoder.test.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { AudioProcessor, downmixPlanarChannelsForExport } from "./audioEncoder";
-
-describe("AudioProcessor.selectSupportedExportCodec", () => {
-	afterEach(() => {
-		vi.unstubAllGlobals();
-	});
-
-	it("falls back to stereo when the source channel count cannot be encoded", async () => {
-		const isConfigSupported = vi.fn(async (config: AudioEncoderConfig) => ({
-			config,
-			supported:
-				config.codec === "mp4a.40.2" &&
-				config.sampleRate === 44100 &&
-				config.numberOfChannels === 2,
-		}));
-		vi.stubGlobal("AudioEncoder", { isConfigSupported });
-
-		const codec = await AudioProcessor.selectSupportedExportCodec(44100, 8);
-
-		expect(codec).toMatchObject({
-			encoderCodec: "mp4a.40.2",
-			muxerCodec: "aac",
-			sampleRate: 44100,
-			numberOfChannels: 2,
-		});
-		expect(isConfigSupported).toHaveBeenCalledWith({
-			codec: "mp4a.40.2",
-			sampleRate: 44100,
-			numberOfChannels: 8,
-			bitrate: 128000,
-		});
-		expect(isConfigSupported).toHaveBeenCalledWith({
-			codec: "mp4a.40.2",
-			sampleRate: 44100,
-			numberOfChannels: 2,
-			bitrate: 128000,
-		});
-	});
-});
-
-describe("downmixPlanarChannelsForExport", () => {
-	it("preserves non-front Windows system audio channels when exporting stereo", () => {
-		const sourcePlanes = Array.from({ length: 8 }, (_, channel) => {
-			const plane = new Float32Array(2);
-			if (channel === 2) {
-				plane[0] = 0.8;
-				plane[1] = 0.4;
-			}
-			if (channel === 6) {
-				plane[0] = 0.2;
-				plane[1] = 0.1;
-			}
-			return plane;
-		});
-
-		const stereo = downmixPlanarChannelsForExport(sourcePlanes, 2);
-
-		expect(stereo[0]).toBeGreaterThan(0);
-		expect(stereo[1]).toBeGreaterThan(0);
-		expect(stereo[2]).toBeGreaterThan(0);
-		expect(stereo[3]).toBeGreaterThan(0);
-	});
-
-	it("duplicates mono microphone audio when exporting stereo", () => {
-		const mono = new Float32Array([0.25, -0.5]);
-
-		const stereo = downmixPlanarChannelsForExport([mono], 2);
-
-		expect(Array.from(stereo)).toEqual([0.25, -0.5, 0.25, -0.5]);
-	});
-});
diff --git a/src/lib/exporter/audioEncoder.ts b/src/lib/exporter/audioEncoder.ts
deleted file mode 100644
index 506f21c170..0000000000
--- a/src/lib/exporter/audioEncoder.ts
+++ /dev/null
@@ -1,1227 +0,0 @@
-import { WebDemuxer } from "web-demuxer";
-import {
-	MAX_NATIVE_PLAYBACK_RATE,
-	type SpeedRegion,
-	type TrimRegion,
-} from "@/components/video-editor/types";
-import { WsolaTimeStretcher } from "./audioTimeStretch";
-import type { ExportAudioMuxerCodec, VideoMuxer } from "./muxer";
-import { PlanarChunkQueue } from "./planarChunkQueue";
-import {
-	buildSpeedSegments,
-	maxTimelineSpeed,
-	type SpeedTimelineSegment,
-} from "./timelineSegments";
-
-const AUDIO_BITRATE = 128_000;
-const DECODE_BACKPRESSURE_LIMIT = 20;
-const MIN_SPEED_REGION_DELTA_MS = 0.0001;
-const SEEK_TIMEOUT_MS = 5_000;
-// AudioData slice size fed to the encoder from the offline time-stretch path.
-const OFFLINE_OUTPUT_FRAMES = 4096;
-const ENCODE_BACKPRESSURE_LIMIT = 20;
-// Must match streamingDecoder's EPSILON_SEC so the offline audio segment lengths
-// use the same per-frame quantization as the video output.
-const VIDEO_EPSILON_SEC = 0.001;
-
-export interface ExportAudioCodec {
-	encoderCodec: string;
-	muxerCodec: ExportAudioMuxerCodec;
-	label: string;
-	sampleRate: number;
-	numberOfChannels: number;
-}
-
-type ExportAudioCodecCandidate = Omit<ExportAudioCodec, "sampleRate" | "numberOfChannels">;
-
-const EXPORT_AUDIO_CODECS: ExportAudioCodecCandidate[] = [
-	{ encoderCodec: "mp4a.40.2", muxerCodec: "aac", label: "AAC" },
-	{ encoderCodec: "opus", muxerCodec: "opus", label: "Opus" },
-];
-
-function averageChannels(sourcePlanes: Float32Array[], frame: number) {
-	let mixed = 0;
-	for (const plane of sourcePlanes) {
-		mixed += plane[frame] ?? 0;
-	}
-	return mixed / Math.max(1, sourcePlanes.length);
-}
-
-function weightedSample(
-	sourcePlanes: Float32Array[],
-	frame: number,
-	weights: Array<[channel: number, weight: number]>,
-) {
-	let mixed = 0;
-	let weightSum = 0;
-	for (const [channel, weight] of weights) {
-		const sample = sourcePlanes[channel]?.[frame];
-		if (typeof sample !== "number") {
-			continue;
-		}
-		mixed += sample * weight;
-		weightSum += weight;
-	}
-	return weightSum > 0 ? mixed / weightSum : averageChannels(sourcePlanes, frame);
-}
-
-function getStereoDownmixWeights(sourceChannels: number) {
-	const centerWeight = Math.SQRT1_2;
-	const surroundWeight = Math.SQRT1_2;
-	const lfeWeight = 0.5;
-
-	if (sourceChannels >= 8) {
-		// Windows 7.1 order: FL, FR, FC, LFE, BL, BR, SL, SR.
-		return {
-			left: [
-				[0, 1],
-				[2, centerWeight],
-				[3, lfeWeight],
-				[4, surroundWeight],
-				[6, surroundWeight],
-			] satisfies Array<[number, number]>,
-			right: [
-				[1, 1],
-				[2, centerWeight],
-				[3, lfeWeight],
-				[5, surroundWeight],
-				[7, surroundWeight],
-			] satisfies Array<[number, number]>,
-		};
-	}
-
-	if (sourceChannels >= 6) {
-		// Windows 5.1 order: FL, FR, FC, LFE, BL, BR.
-		return {
-			left: [
-				[0, 1],
-				[2, centerWeight],
-				[3, lfeWeight],
-				[4, surroundWeight],
-			] satisfies Array<[number, number]>,
-			right: [
-				[1, 1],
-				[2, centerWeight],
-				[3, lfeWeight],
-				[5, surroundWeight],
-			] satisfies Array<[number, number]>,
-		};
-	}
-
-	if (sourceChannels >= 4) {
-		return {
-			left: [
-				[0, 1],
-				[2, surroundWeight],
-			] satisfies Array<[number, number]>,
-			right: [
-				[1, 1],
-				[3, surroundWeight],
-			] satisfies Array<[number, number]>,
-		};
-	}
-
-	return {
-		left: [
-			[0, 1],
-			[2, centerWeight],
-		] satisfies Array<[number, number]>,
-		right: [
-			[1, 1],
-			[2, centerWeight],
-		] satisfies Array<[number, number]>,
-	};
-}
-
-export function downmixPlanarChannelsForExport(
-	sourcePlanes: Float32Array[],
-	targetChannels: number,
-): Float32Array {
-	const frameCount = sourcePlanes[0]?.length ?? 0;
-	const output = new Float32Array(frameCount * targetChannels);
-
-	if (targetChannels === 1) {
-		for (let frame = 0; frame < frameCount; frame++) {
-			output[frame] = averageChannels(sourcePlanes, frame);
-		}
-		return output;
-	}
-
-	if (targetChannels !== 2) {
-		throw new Error(`Unsupported target channel count: ${targetChannels}`);
-	}
-
-	if (sourcePlanes.length === 1) {
-		output.set(sourcePlanes[0], 0);
-		output.set(sourcePlanes[0], frameCount);
-		return output;
-	}
-
-	if (sourcePlanes.length === 2) {
-		output.set(sourcePlanes[0], 0);
-		output.set(sourcePlanes[1], frameCount);
-		return output;
-	}
-
-	const weights = getStereoDownmixWeights(sourcePlanes.length);
-	for (let frame = 0; frame < frameCount; frame++) {
-		output[frame] = weightedSample(sourcePlanes, frame, weights.left);
-		output[frameCount + frame] = weightedSample(sourcePlanes, frame, weights.right);
-	}
-	return output;
-}
-
-export class AudioProcessor {
-	private cancelled = false;
-
-	static async selectSupportedExportCodec(
-		sampleRate: number,
-		numberOfChannels: number,
-	): Promise<ExportAudioCodec | null> {
-		const channelOptions = [numberOfChannels];
-		if (numberOfChannels > 2) {
-			channelOptions.push(2);
-		}
-
-		if (!channelOptions.includes(1)) {
-			channelOptions.push(1);
-		}
-
-		for (const codec of EXPORT_AUDIO_CODECS) {
-			for (const channels of channelOptions) {
-				const support = await AudioEncoder.isConfigSupported({
-					codec: codec.encoderCodec,
-					sampleRate,
-					numberOfChannels: channels,
-					bitrate: AUDIO_BITRATE,
-				});
-				if (support.supported) {
-					return { ...codec, sampleRate, numberOfChannels: channels };
-				}
-			}
-		}
-
-		return null;
-	}
-
-	static async selectSupportedExportCodecForSource(
-		demuxer: WebDemuxer,
-	): Promise<ExportAudioCodec | null> {
-		let audioConfig: AudioDecoderConfig;
-		try {
-			audioConfig = await demuxer.getDecoderConfig("audio");
-		} catch {
-			return null;
-		}
-
-		const codecCheck = await AudioDecoder.isConfigSupported(audioConfig);
-		if (!codecCheck.supported) {
-			console.warn("[AudioProcessor] Audio codec not supported:", audioConfig.codec);
-			return null;
-		}
-
-		return AudioProcessor.selectSupportedExportCodec(
-			audioConfig.sampleRate || 48000,
-			audioConfig.numberOfChannels || 2,
-		);
-	}
-
-	/**
-	 * Two modes: no speed regions uses the fast WebCodecs trim-only pipeline; speed
-	 * regions use the pitch-preserving rendered timeline pipeline.
-	 */
-	async process(
-		demuxer: WebDemuxer,
-		muxer: VideoMuxer,
-		videoUrl: string,
-		trimRegions: TrimRegion[] | undefined,
-		speedRegions: SpeedRegion[] | undefined,
-		validatedDurationSec: number,
-		exportCodec: ExportAudioCodec,
-		targetFrameRate: number,
-	): Promise<void> {
-		const sortedTrims = trimRegions ? [...trimRegions].sort((a, b) => a.startMs - b.startMs) : [];
-		const sortedSpeedRegions = speedRegions
-			? [...speedRegions]
-					.filter((region) => region.endMs - region.startMs > MIN_SPEED_REGION_DELTA_MS)
-					.sort((a, b) => a.startMs - b.startMs)
-			: [];
-
-		// Speed edits need pitch preservation. Segments at or below the native
-		// playbackRate cap use the real-time <audio> capture (proven, sounds best);
-		// anything faster can't be played in real time, so the whole timeline is
-		// rendered offline with a WSOLA time-stretch instead.
-		if (sortedSpeedRegions.length > 0) {
-			const segments = buildSpeedSegments(validatedDurationSec, sortedTrims, sortedSpeedRegions);
-
-			if (maxTimelineSpeed(segments) > MAX_NATIVE_PLAYBACK_RATE) {
-				await this.renderOfflineTimelineAudio(
-					demuxer,
-					muxer,
-					segments,
-					exportCodec,
-					targetFrameRate,
-				);
-				return;
-			}
-
-			const renderedAudioBlob = await this.renderPitchPreservedTimelineAudio(
-				videoUrl,
-				sortedTrims,
-				sortedSpeedRegions,
-				validatedDurationSec,
-			);
-			if (!this.cancelled && renderedAudioBlob.size > 0) {
-				await this.muxRenderedAudioBlob(renderedAudioBlob, muxer, exportCodec);
-				return;
-			}
-			return;
-		}
-
-		// No speed edits: demux/decode/encode with trim timestamp remap. The +0.5s mirrors
-		// streamingDecoder.decodeAll's read window so both paths read the same distance past
-		// the validated duration boundary.
-		const readEndSec = validatedDurationSec + 0.5;
-		await this.processTrimOnlyAudio(demuxer, muxer, sortedTrims, readEndSec, exportCodec);
-	}
-
-	// Trim-only path, used for projects without speed regions.
-	private async processTrimOnlyAudio(
-		demuxer: WebDemuxer,
-		muxer: VideoMuxer,
-		sortedTrims: TrimRegion[],
-		readEndSec?: number,
-		exportCodec?: ExportAudioCodec,
-	): Promise<void> {
-		let audioConfig: AudioDecoderConfig;
-		try {
-			audioConfig = await demuxer.getDecoderConfig("audio");
-		} catch {
-			console.warn("[AudioProcessor] No audio track found, skipping");
-			return;
-		}
-
-		const codecCheck = await AudioDecoder.isConfigSupported(audioConfig);
-		if (!codecCheck.supported) {
-			console.warn("[AudioProcessor] Audio codec not supported:", audioConfig.codec);
-			return;
-		}
-
-		// Phase 1: decode, skipping trimmed regions.
-		const decodedFrames: AudioData[] = [];
-
-		const decoder = new AudioDecoder({
-			output: (data: AudioData) => decodedFrames.push(data),
-			error: (e: DOMException) => console.error("[AudioProcessor] Decode error:", e),
-		});
-		decoder.configure(audioConfig);
-
-		const safeReadEndSec =
-			typeof readEndSec === "number" && Number.isFinite(readEndSec)
-				? Math.max(0, readEndSec)
-				: undefined;
-		const audioStream =
-			safeReadEndSec !== undefined
-				? demuxer.read("audio", 0, safeReadEndSec)
-				: demuxer.read("audio");
-		const reader = audioStream.getReader();
-
-		try {
-			while (!this.cancelled) {
-				const { done, value: chunk } = await reader.read();
-				if (done || !chunk) break;
-
-				const timestampMs = chunk.timestamp / 1000;
-				if (this.isInTrimRegion(timestampMs, sortedTrims)) continue;
-
-				decoder.decode(chunk);
-
-				while (decoder.decodeQueueSize > DECODE_BACKPRESSURE_LIMIT && !this.cancelled) {
-					await new Promise((resolve) => setTimeout(resolve, 1));
-				}
-			}
-		} finally {
-			try {
-				await reader.cancel();
-			} catch {
-				/* reader already closed */
-			}
-		}
-
-		if (decoder.state === "configured") {
-			await decoder.flush();
-			decoder.close();
-		}
-
-		if (this.cancelled || decodedFrames.length === 0) {
-			for (const frame of decodedFrames) frame.close();
-			return;
-		}
-
-		// Phase 2: re-encode with timestamps adjusted for trim gaps.
-		const encodedChunks: { chunk: EncodedAudioChunk; meta?: EncodedAudioChunkMetadata }[] = [];
-
-		const encoder = new AudioEncoder({
-			output: (chunk: EncodedAudioChunk, meta?: EncodedAudioChunkMetadata) => {
-				encodedChunks.push({ chunk, meta });
-			},
-			error: (e: DOMException) => console.error("[AudioProcessor] Encode error:", e),
-		});
-
-		const sampleRate = audioConfig.sampleRate || 48000;
-		const channels = audioConfig.numberOfChannels || 2;
-		const selectedCodec =
-			exportCodec ?? (await AudioProcessor.selectSupportedExportCodec(sampleRate, channels));
-		if (!selectedCodec) {
-			console.warn("[AudioProcessor] No supported audio export codec, skipping audio");
-			for (const frame of decodedFrames) frame.close();
-			return;
-		}
-
-		const outputSampleRate = selectedCodec.sampleRate || sampleRate;
-		const outputChannels = selectedCodec.numberOfChannels || channels;
-		const encodeConfig: AudioEncoderConfig = {
-			codec: selectedCodec.encoderCodec,
-			sampleRate: outputSampleRate,
-			numberOfChannels: outputChannels,
-			bitrate: AUDIO_BITRATE,
-		};
-
-		const encodeSupport = await AudioEncoder.isConfigSupported(encodeConfig);
-		if (!encodeSupport.supported) {
-			console.warn(
-				`[AudioProcessor] ${selectedCodec.label} encoding not supported, skipping audio`,
-			);
-			for (const frame of decodedFrames) frame.close();
-			return;
-		}
-
-		encoder.configure(encodeConfig);
-
-		for (const audioData of decodedFrames) {
-			if (this.cancelled) {
-				audioData.close();
-				continue;
-			}
-
-			const timestampMs = audioData.timestamp / 1000;
-			const trimOffsetMs = this.computeTrimOffset(timestampMs, sortedTrims);
-			const adjustedTimestampUs = audioData.timestamp - trimOffsetMs * 1000;
-
-			const adjusted = this.cloneForEncoding(
-				audioData,
-				Math.max(0, adjustedTimestampUs),
-				outputChannels,
-			);
-			audioData.close();
-
-			encoder.encode(adjusted);
-			adjusted.close();
-		}
-
-		if (encoder.state === "configured") {
-			await encoder.flush();
-			encoder.close();
-		}
-
-		// Phase 3: flush encoded chunks to muxer.
-		for (const { chunk, meta } of encodedChunks) {
-			if (this.cancelled) break;
-			await muxer.addAudioChunk(chunk, meta);
-		}
-
-		console.log(
-			`[AudioProcessor] Processed ${decodedFrames.length} audio frames, encoded ${encodedChunks.length} chunks`,
-		);
-	}
-
-	// Speed-aware path mirroring preview semantics (trim skipping + playbackRate). Relies on
-	// browser media playback to preserve pitch and avoid the chipmunk effect.
-	private async renderPitchPreservedTimelineAudio(
-		videoUrl: string,
-		trimRegions: TrimRegion[],
-		speedRegions: SpeedRegion[],
-		validatedDurationSec: number,
-	): Promise<Blob> {
-		const media = document.createElement("audio");
-		media.src = videoUrl;
-		media.preload = "auto";
-
-		const pitchMedia = media as HTMLMediaElement & {
-			preservesPitch?: boolean;
-			mozPreservesPitch?: boolean;
-			webkitPreservesPitch?: boolean;
-		};
-		pitchMedia.preservesPitch = true;
-		pitchMedia.mozPreservesPitch = true;
-		pitchMedia.webkitPreservesPitch = true;
-
-		await this.waitForLoadedMetadata(media);
-		if (this.cancelled) {
-			throw new Error("Export cancelled");
-		}
-
-		const audioContext = new AudioContext();
-		const sourceNode = audioContext.createMediaElementSource(media);
-		const destinationNode = audioContext.createMediaStreamDestination();
-		sourceNode.connect(destinationNode);
-
-		let rafId: number | null = null;
-		let recorder: MediaRecorder | null = null;
-		let recordedBlobPromise: Promise<Blob> | null = null;
-
-		try {
-			if (audioContext.state === "suspended") {
-				await audioContext.resume();
-			}
-
-			// Skip initial trim region(s) before recording so the first rAF frames don't
-			// capture trimmed audio. Loops to handle back-to-back/overlapping trims at t=0.
-			const effectiveEnd = validatedDurationSec;
-			let startPosition = 0;
-			for (let i = 0; i <= trimRegions.length; i++) {
-				const activeTrim = this.findActiveTrimRegion(startPosition * 1000, trimRegions);
-				if (!activeTrim) break;
-				startPosition = activeTrim.endMs / 1000;
-				if (startPosition >= effectiveEnd) break;
-			}
-
-			if (startPosition >= effectiveEnd) {
-				// Everything is trimmed; return a silent blob.
-				return new Blob([], { type: "audio/webm" });
-			}
-
-			await this.seekTo(media, startPosition);
-
-			// Set initial playback rate for the starting position.
-			const initialSpeedRegion = this.findActiveSpeedRegion(startPosition * 1000, speedRegions);
-			if (initialSpeedRegion) {
-				media.playbackRate = initialSpeedRegion.speed;
-			}
-
-			// Start recording only after seeking past trims.
-			const recording = this.startAudioRecording(destinationNode.stream);
-			recorder = recording.recorder;
-			recordedBlobPromise = recording.recordedBlobPromise;
-			await media.play();
-
-			await new Promise<void>((resolve, reject) => {
-				const cleanup = () => {
-					if (rafId !== null) {
-						cancelAnimationFrame(rafId);
-						rafId = null;
-					}
-					media.removeEventListener("error", onError);
-					media.removeEventListener("ended", onEnded);
-				};
-
-				const onError = () => {
-					cleanup();
-					reject(new Error("Failed while rendering speed-adjusted audio timeline"));
-				};
-
-				const onEnded = () => {
-					cleanup();
-					resolve();
-				};
-
-				const tick = () => {
-					if (this.cancelled) {
-						cleanup();
-						resolve();
-						return;
-					}
-
-					// Stop at validated duration; media.duration can be inflated by bad
-					// container metadata.
-					if (media.currentTime >= validatedDurationSec) {
-						media.pause();
-						cleanup();
-						resolve();
-						return;
-					}
-
-					const currentTimeMs = media.currentTime * 1000;
-					const activeTrimRegion = this.findActiveTrimRegion(currentTimeMs, trimRegions);
-
-					if (activeTrimRegion && !media.paused && !media.ended) {
-						const skipToTime = activeTrimRegion.endMs / 1000;
-						if (skipToTime >= media.duration || skipToTime >= validatedDurationSec) {
-							media.pause();
-							cleanup();
-							resolve();
-							return;
-						}
-						// Pause recording during the seek so we don't capture silence/noise.
-						media.pause();
-						if (recorder?.state === "recording") recorder.pause();
-						const onSeeked = () => {
-							clearTimeout(seekTimer);
-							if (this.cancelled) {
-								cleanup();
-								resolve();
-								return;
-							}
-							if (recorder?.state === "paused") recorder.resume();
-							media
-								.play()
-								.then(() => {
-									if (!this.cancelled) rafId = requestAnimationFrame(tick);
-								})
-								.catch((err) => {
-									cleanup();
-									reject(
-										new Error(
-											`Failed to resume playback after trim seek: ${err instanceof Error ? err.message : String(err)}`,
-										),
-									);
-								});
-						};
-						const seekTimer = window.setTimeout(() => {
-							media.removeEventListener("seeked", onSeeked);
-							cleanup();
-							reject(new Error("Audio seek timed out while skipping trim region"));
-						}, SEEK_TIMEOUT_MS);
-						media.addEventListener("seeked", onSeeked, { once: true });
-						media.currentTime = skipToTime;
-						return;
-					}
-
-					const activeSpeedRegion = this.findActiveSpeedRegion(currentTimeMs, speedRegions);
-					const playbackRate = activeSpeedRegion ? activeSpeedRegion.speed : 1;
-					if (Math.abs(media.playbackRate - playbackRate) > 0.0001) {
-						media.playbackRate = playbackRate;
-					}
-
-					if (!media.paused && !media.ended) {
-						rafId = requestAnimationFrame(tick);
-					} else {
-						cleanup();
-						resolve();
-					}
-				};
-
-				media.addEventListener("error", onError, { once: true });
-				media.addEventListener("ended", onEnded, { once: true });
-				rafId = requestAnimationFrame(tick);
-			});
-		} finally {
-			if (rafId !== null) {
-				cancelAnimationFrame(rafId);
-			}
-			media.pause();
-			if (recorder && recorder.state !== "inactive") {
-				recorder.stop();
-			}
-			destinationNode.stream.getTracks().forEach((track) => track.stop());
-			sourceNode.disconnect();
-			destinationNode.disconnect();
-			await audioContext.close();
-			media.src = "";
-			media.load();
-		}
-
-		if (!recordedBlobPromise) {
-			// Either an early return fired or startAudioRecording set this before playback
-			// resolved. Reaching here means that broke; fail loud rather than return silence.
-			throw new Error("Audio recorder finished without assigning recordedBlobPromise");
-		}
-		const recordedBlob = await recordedBlobPromise;
-		if (this.cancelled) {
-			throw new Error("Export cancelled");
-		}
-		return recordedBlob;
-	}
-
-	/**
-	 * Offline pitch-preserved timeline audio for projects that contain a segment
-	 * faster than the native playbackRate cap (which the real-time capture path
-	 * can't reach). Streams the source once, routes each frame's PCM into the
-	 * active timeline segment, applies a WSOLA time-stretch per segment, and
-	 * encodes the result — clamping each segment to its exact expected length so
-	 * the audio stays locked to the (independently retimed) video.
-	 */
-	private async renderOfflineTimelineAudio(
-		demuxer: WebDemuxer,
-		muxer: VideoMuxer,
-		segments: SpeedTimelineSegment[],
-		exportCodec: ExportAudioCodec,
-		targetFrameRate: number,
-	): Promise<void> {
-		let audioConfig: AudioDecoderConfig;
-		try {
-			audioConfig = await demuxer.getDecoderConfig("audio");
-		} catch {
-			console.warn("[AudioProcessor] No audio track found, skipping");
-			return;
-		}
-
-		const codecCheck = await AudioDecoder.isConfigSupported(audioConfig);
-		if (!codecCheck.supported) {
-			console.warn("[AudioProcessor] Audio codec not supported:", audioConfig.codec);
-			return;
-		}
-
-		const sampleRate = audioConfig.sampleRate || 48000;
-		const outputChannels = exportCodec.numberOfChannels || audioConfig.numberOfChannels || 2;
-		const outputSampleRate = exportCodec.sampleRate || sampleRate;
-
-		const encodeConfig: AudioEncoderConfig = {
-			codec: exportCodec.encoderCodec,
-			sampleRate: outputSampleRate,
-			numberOfChannels: outputChannels,
-			bitrate: AUDIO_BITRATE,
-		};
-		const encodeSupport = await AudioEncoder.isConfigSupported(encodeConfig);
-		if (!encodeSupport.supported) {
-			console.warn(`[AudioProcessor] ${exportCodec.label} encoding not supported, skipping audio`);
-			return;
-		}
-
-		const encodedChunks: { chunk: EncodedAudioChunk; meta?: EncodedAudioChunkMetadata }[] = [];
-		const encoder = new AudioEncoder({
-			output: (chunk, meta) => encodedChunks.push({ chunk, meta }),
-			error: (e: DOMException) => console.error("[AudioProcessor] Encode error:", e),
-		});
-		encoder.configure(encodeConfig);
-
-		// Output-side accumulator: a chunk queue (O(1) append, front-drained) coalesced
-		// into fixed-size AudioData slices with running (monotonic) output timestamps.
-		const outQueue = new PlanarChunkQueue(outputChannels);
-		let outTimestampSamples = 0;
-
-		const appendOutput = (planes: Float32Array[], count: number) => {
-			outQueue.push(planes, count);
-		};
-
-		const flushOutput = (drainAll: boolean) => {
-			while (outQueue.length >= OFFLINE_OUTPUT_FRAMES || (drainAll && outQueue.length > 0)) {
-				const take = Math.min(OFFLINE_OUTPUT_FRAMES, outQueue.length);
-				const data = outQueue.take(take);
-				const audioData = new AudioData({
-					format: "f32-planar",
-					sampleRate: outputSampleRate,
-					numberOfFrames: take,
-					numberOfChannels: outputChannels,
-					timestamp: Math.round((outTimestampSamples / outputSampleRate) * 1_000_000),
-					data: data.buffer as ArrayBuffer,
-				});
-				outTimestampSamples += take;
-				encoder.encode(audioData);
-				audioData.close();
-			}
-		};
-
-		// Per-segment state.
-		let segIdx = 0;
-		let stretcher: WsolaTimeStretcher | null = null;
-		let segExpectedOut = 0;
-		let segEmittedOut = 0;
-
-		const startSegment = (seg: SpeedTimelineSegment) => {
-			// Match the video path's per-segment frame quantization exactly (streamingDecoder
-			// emits ceil((dur - EPSILON)/speed * fps) frames) so audio and video advance by
-			// the same amount each segment and never accumulate drift.
-			const frameCount = Math.ceil(
-				((seg.endSec - seg.startSec - VIDEO_EPSILON_SEC) / seg.speed) * targetFrameRate,
-			);
-			segExpectedOut = Math.max(0, Math.round((frameCount / targetFrameRate) * outputSampleRate));
-			segEmittedOut = 0;
-			stretcher = new WsolaTimeStretcher({
-				sampleRate,
-				channels: outputChannels,
-				speed: seg.speed,
-				expectedOutputSamples: segExpectedOut,
-			});
-		};
-
-		// Clamp each segment's emitted output to its expected length (drops the WSOLA
-		// tail overshoot; pads with silence on the rare underrun) so cumulative A/V
-		// timing matches the video the audio is retimed against.
-		const emitStretched = (planes: Float32Array[]) => {
-			const produced = planes[0]?.length ?? 0;
-			const allowed = Math.max(0, segExpectedOut - segEmittedOut);
-			const take = Math.min(produced, allowed);
-			appendOutput(planes, take);
-			segEmittedOut += take;
-		};
-
-		// Feed `count` source-domain silence samples into the current segment's
-		// stretcher (compressed by its speed, then clamped/encoded like real audio).
-		const feedSilence = (count: number) => {
-			if (!stretcher) return;
-			let remaining = count;
-			while (remaining > 0) {
-				const n = Math.min(8192, remaining);
-				const silence = Array.from({ length: outputChannels }, () => new Float32Array(n));
-				emitStretched(stretcher.push(silence));
-				remaining -= n;
-			}
-		};
-
-		const finalizeSegment = () => {
-			if (!stretcher) return;
-			emitStretched(stretcher.flush());
-			// Intentional: pad the deficit with silence when WSOLA under-fills a short
-			// high-speed segment, so the segment keeps its exact A/V-locked length. Do
-			// not "fix" this by removing the pad.
-			if (segEmittedOut < segExpectedOut) {
-				const pad = segExpectedOut - segEmittedOut;
-				const silence = Array.from({ length: outputChannels }, () => new Float32Array(pad));
-				appendOutput(silence, pad);
-				segEmittedOut += pad;
-			}
-			stretcher = null;
-		};
-
-		const segStartSample = (seg: SpeedTimelineSegment) => Math.round(seg.startSec * sampleRate);
-		const segEndSample = (seg: SpeedTimelineSegment) => Math.round(seg.endSec * sampleRate);
-
-		const routeFrame = (planes: Float32Array[], frameStartSample: number, frameCount: number) => {
-			let local = 0;
-			while (local < frameCount && segIdx < segments.length) {
-				const seg = segments[segIdx];
-				const segStart = segStartSample(seg);
-				const segEnd = segEndSample(seg);
-				const currentAbs = frameStartSample + local;
-
-				if (currentAbs < segStart) {
-					// In a trimmed gap (or before the first segment): discard.
-					local += Math.min(segStart - currentAbs, frameCount - local);
-					continue;
-				}
-				if (currentAbs >= segEnd) {
-					finalizeSegment();
-					segIdx += 1;
-					continue;
-				}
-				if (!stretcher) {
-					startSegment(seg);
-					// If the very first source sample lands after the timeline origin (codec
-					// priming, or an audio track that starts after the video), fill the head
-					// with leading silence so real audio keeps its true source-time position.
-					// The video path holds its first frame over the same head, so this keeps
-					// A/V aligned; it is a no-op when the first sample is at 0, and negative
-					// preroll was already discarded by the `currentAbs < segStart` branch above.
-					if (segIdx === 0 && currentAbs > segStart) feedSilence(currentAbs - segStart);
-				}
-				const take = Math.min(segEnd, frameStartSample + frameCount) - currentAbs;
-				const slice = planes.map((p) => p.subarray(local, local + take));
-				emitStretched((stretcher as WsolaTimeStretcher).push(slice));
-				local += take;
-			}
-		};
-
-		// Streaming decode: frames arrive in source order via the decoder callback.
-		const pending: AudioData[] = [];
-		const decoder = new AudioDecoder({
-			output: (data: AudioData) => pending.push(data),
-			error: (e: DOMException) => console.error("[AudioProcessor] Decode error:", e),
-		});
-		decoder.configure(audioConfig);
-
-		const drainPending = async () => {
-			while (pending.length > 0) {
-				if (this.cancelled) {
-					for (const d of pending) d.close();
-					pending.length = 0;
-					return;
-				}
-				const data = pending.shift();
-				if (!data) continue;
-				const frameCount = data.numberOfFrames;
-				const sourceChannels = data.numberOfChannels;
-				const srcPlanes: Float32Array[] = [];
-				for (let c = 0; c < sourceChannels; c++) {
-					const plane = new Float32Array(frameCount);
-					data.copyTo(plane, { format: "f32-planar", planeIndex: c });
-					srcPlanes.push(plane);
-				}
-				// Raw source timestamps — the same origin the video decoder uses
-				// (streamingDecoder), so audio and video stay in one coordinate system.
-				// Frames before the first segment start (e.g. negative-timestamp codec
-				// preroll, or a leading trim) are correctly discarded by routeFrame.
-				const frameStartSample = Math.round((data.timestamp / 1_000_000) * sampleRate);
-				data.close();
-
-				// Match source channels through untouched; otherwise downmix (to 1 or 2).
-				let planes: Float32Array[];
-				if (outputChannels === sourceChannels) {
-					planes = srcPlanes;
-				} else {
-					const downmixed = downmixPlanarChannelsForExport(srcPlanes, outputChannels);
-					planes = [];
-					for (let c = 0; c < outputChannels; c++) {
-						planes.push(downmixed.subarray(c * frameCount, (c + 1) * frameCount));
-					}
-				}
-
-				routeFrame(planes, frameStartSample, frameCount);
-				flushOutput(false);
-
-				while (encoder.encodeQueueSize > ENCODE_BACKPRESSURE_LIMIT && !this.cancelled) {
-					await new Promise((resolve) => setTimeout(resolve, 1));
-				}
-			}
-		};
-
-		// Read past the last segment's source end (mirrors streamingDecoder's +0.5s
-		// window so both paths read the same distance past the boundary).
-		const lastSegmentEndSec = segments.length > 0 ? segments[segments.length - 1].endSec : 0;
-		const readEndSec = lastSegmentEndSec + 0.5;
-		const reader = demuxer.read("audio", 0, readEndSec).getReader();
-		try {
-			while (!this.cancelled) {
-				const { done, value: chunk } = await reader.read();
-				if (done || !chunk) break;
-				decoder.decode(chunk);
-				while (decoder.decodeQueueSize > DECODE_BACKPRESSURE_LIMIT && !this.cancelled) {
-					await new Promise((resolve) => setTimeout(resolve, 1));
-				}
-				await drainPending();
-			}
-		} finally {
-			try {
-				await reader.cancel();
-			} catch {
-				/* reader already closed */
-			}
-		}
-
-		if (decoder.state === "configured") {
-			if (!this.cancelled) {
-				await decoder.flush();
-			}
-			decoder.close();
-		}
-		await drainPending();
-
-		if (this.cancelled) {
-			if (encoder.state === "configured") encoder.close();
-			return;
-		}
-
-		// Finalize the segment still open at end-of-stream, then pad any segments that
-		// never received audio (source shorter than the timeline) with silence.
-		if (stretcher) {
-			finalizeSegment();
-			segIdx += 1;
-		}
-		for (; segIdx < segments.length; segIdx++) {
-			startSegment(segments[segIdx]);
-			finalizeSegment();
-		}
-
-		flushOutput(true);
-
-		if (encoder.state === "configured") {
-			await encoder.flush();
-			encoder.close();
-		}
-
-		for (const { chunk, meta } of encodedChunks) {
-			if (this.cancelled) break;
-			await muxer.addAudioChunk(chunk, meta);
-		}
-
-		console.log(
-			`[AudioProcessor] Offline timeline audio: ${segments.length} segments, ${encodedChunks.length} chunks`,
-		);
-	}
-
-	// Demux the rendered speed-adjusted blob and feed its chunks into the MP4 muxer.
-	private async muxRenderedAudioBlob(
-		blob: Blob,
-		muxer: VideoMuxer,
-		exportCodec: ExportAudioCodec,
-	): Promise<void> {
-		if (this.cancelled) return;
-
-		const file = new File([blob], "speed-audio.webm", { type: blob.type || "audio/webm" });
-		const wasmUrl = new URL("./wasm/web-demuxer.wasm", window.location.href).href;
-		const demuxer = new WebDemuxer({ wasmFilePath: wasmUrl });
-
-		try {
-			await demuxer.load(file);
-			await this.processTrimOnlyAudio(demuxer, muxer, [], undefined, exportCodec);
-		} finally {
-			try {
-				demuxer.destroy();
-			} catch {
-				/* ignore */
-			}
-		}
-	}
-
-	private startAudioRecording(stream: MediaStream): {
-		recorder: MediaRecorder;
-		recordedBlobPromise: Promise<Blob>;
-	} {
-		const mimeType = this.getSupportedAudioMimeType();
-		const options: MediaRecorderOptions = {
-			audioBitsPerSecond: AUDIO_BITRATE,
-			...(mimeType ? { mimeType } : {}),
-		};
-
-		const recorder = new MediaRecorder(stream, options);
-		const chunks: Blob[] = [];
-
-		const recordedBlobPromise = new Promise<Blob>((resolve, reject) => {
-			recorder.ondataavailable = (event: BlobEvent) => {
-				if (event.data && event.data.size > 0) {
-					chunks.push(event.data);
-				}
-			};
-			recorder.onerror = () => {
-				reject(new Error("MediaRecorder failed while capturing speed-adjusted audio"));
-			};
-			recorder.onstop = () => {
-				const type = mimeType || chunks[0]?.type || "audio/webm";
-				resolve(new Blob(chunks, { type }));
-			};
-		});
-
-		recorder.start();
-		return { recorder, recordedBlobPromise };
-	}
-
-	private getSupportedAudioMimeType(): string | undefined {
-		const candidates = ["audio/webm;codecs=opus", "audio/webm"];
-		for (const candidate of candidates) {
-			if (MediaRecorder.isTypeSupported(candidate)) {
-				return candidate;
-			}
-		}
-		return undefined;
-	}
-
-	private waitForLoadedMetadata(media: HTMLMediaElement): Promise<void> {
-		if (Number.isFinite(media.duration) && media.readyState >= HTMLMediaElement.HAVE_METADATA) {
-			return Promise.resolve();
-		}
-
-		return new Promise<void>((resolve, reject) => {
-			const onLoaded = () => {
-				cleanup();
-				resolve();
-			};
-			const onError = () => {
-				cleanup();
-				reject(new Error("Failed to load media metadata for speed-adjusted audio"));
-			};
-			const cleanup = () => {
-				media.removeEventListener("loadedmetadata", onLoaded);
-				media.removeEventListener("error", onError);
-			};
-
-			media.addEventListener("loadedmetadata", onLoaded);
-			media.addEventListener("error", onError, { once: true });
-		});
-	}
-
-	private seekTo(media: HTMLMediaElement, targetSec: number): Promise<void> {
-		if (Math.abs(media.currentTime - targetSec) < 0.0001) {
-			return Promise.resolve();
-		}
-
-		return new Promise<void>((resolve, reject) => {
-			const onSeeked = () => {
-				cleanup();
-				resolve();
-			};
-			const onError = () => {
-				cleanup();
-				reject(new Error("Failed to seek media for speed-adjusted audio"));
-			};
-			const cleanup = () => {
-				media.removeEventListener("seeked", onSeeked);
-				media.removeEventListener("error", onError);
-			};
-
-			media.addEventListener("seeked", onSeeked, { once: true });
-			media.addEventListener("error", onError, { once: true });
-			media.currentTime = targetSec;
-		});
-	}
-
-	private findActiveTrimRegion(
-		currentTimeMs: number,
-		trimRegions: TrimRegion[],
-	): TrimRegion | null {
-		return (
-			trimRegions.find(
-				(region) => currentTimeMs >= region.startMs && currentTimeMs < region.endMs,
-			) || null
-		);
-	}
-
-	private findActiveSpeedRegion(
-		currentTimeMs: number,
-		speedRegions: SpeedRegion[],
-	): SpeedRegion | null {
-		return (
-			speedRegions.find(
-				(region) => currentTimeMs >= region.startMs && currentTimeMs < region.endMs,
-			) || null
-		);
-	}
-
-	private cloneForEncoding(
-		src: AudioData,
-		newTimestamp: number,
-		targetChannels: number,
-	): AudioData {
-		if (targetChannels !== src.numberOfChannels) {
-			return this.downmixWithTimestamp(src, newTimestamp, targetChannels);
-		}
-
-		if (!src.format) {
-			throw new Error("AudioData format is required for cloning");
-		}
-		const isPlanar = src.format.includes("planar");
-		const numPlanes = isPlanar ? src.numberOfChannels : 1;
-
-		let totalSize = 0;
-		for (let planeIndex = 0; planeIndex < numPlanes; planeIndex++) {
-			totalSize += src.allocationSize({ planeIndex });
-		}
-
-		const buffer = new ArrayBuffer(totalSize);
-		let offset = 0;
-		for (let planeIndex = 0; planeIndex < numPlanes; planeIndex++) {
-			const planeSize = src.allocationSize({ planeIndex });
-			src.copyTo(new Uint8Array(buffer, offset, planeSize), { planeIndex });
-			offset += planeSize;
-		}
-
-		return new AudioData({
-			format: src.format,
-			sampleRate: src.sampleRate,
-			numberOfFrames: src.numberOfFrames,
-			numberOfChannels: src.numberOfChannels,
-			timestamp: newTimestamp,
-			data: buffer,
-		});
-	}
-
-	private downmixWithTimestamp(
-		src: AudioData,
-		newTimestamp: number,
-		targetChannels: number,
-	): AudioData {
-		const sourceChannels = src.numberOfChannels;
-		const frameCount = src.numberOfFrames;
-		if (targetChannels < 1 || targetChannels > 2) {
-			throw new Error(`Unsupported target channel count: ${targetChannels}`);
-		}
-
-		const sourcePlanes = Array.from({ length: sourceChannels }, () => new Float32Array(frameCount));
-		for (let channel = 0; channel < sourceChannels; channel++) {
-			src.copyTo(sourcePlanes[channel], {
-				format: "f32-planar",
-				planeIndex: channel,
-			});
-		}
-
-		const output = downmixPlanarChannelsForExport(sourcePlanes, targetChannels);
-
-		return new AudioData({
-			format: "f32-planar",
-			sampleRate: src.sampleRate,
-			numberOfFrames: frameCount,
-			numberOfChannels: targetChannels,
-			timestamp: newTimestamp,
-			data: output.buffer instanceof ArrayBuffer ? output.buffer : output.slice().buffer,
-		});
-	}
-
-	private isInTrimRegion(timestampMs: number, trims: TrimRegion[]): boolean {
-		return trims.some((trim) => timestampMs >= trim.startMs && timestampMs < trim.endMs);
-	}
-
-	private computeTrimOffset(timestampMs: number, trims: TrimRegion[]): number {
-		let offset = 0;
-		for (const trim of trims) {
-			if (trim.endMs <= timestampMs) {
-				offset += trim.endMs - trim.startMs;
-			}
-		}
-		return offset;
-	}
-
-	/**
-	 * Encodes an already-assembled planar PCM timeline (one Float32Array per
-	 * channel, at `sampleRate`) into `exportCodec` and muxes the chunks. Used by
-	 * the v2 multi-asset segment loop: per-segment audio is decoded, concatenated
-	 * and boundary-faded upstream (audioConcatAssembler), then handed here as one
-	 * continuous buffer — so this method only chops it into encoder-sized frames.
-	 */
-	async encodePcmToMuxer(
-		pcm: Float32Array[],
-		sampleRate: number,
-		muxer: VideoMuxer,
-		exportCodec: ExportAudioCodec,
-	): Promise<void> {
-		if (this.cancelled) return;
-		const channels = pcm.length;
-		const totalFrames = pcm[0]?.length ?? 0;
-		if (channels === 0 || totalFrames === 0) return;
-
-		const encodeConfig: AudioEncoderConfig = {
-			codec: exportCodec.encoderCodec,
-			sampleRate,
-			numberOfChannels: channels,
-			bitrate: AUDIO_BITRATE,
-		};
-		const support = await AudioEncoder.isConfigSupported(encodeConfig);
-		if (!support.supported) {
-			console.warn(`[AudioProcessor] ${exportCodec.label} encoding not supported, skipping audio`);
-			return;
-		}
-
-		const encodedChunks: { chunk: EncodedAudioChunk; meta?: EncodedAudioChunkMetadata }[] = [];
-		const encoder = new AudioEncoder({
-			output: (chunk, meta) => encodedChunks.push({ chunk, meta }),
-			error: (e: DOMException) => console.error("[AudioProcessor] Encode error:", e),
-		});
-		encoder.configure(encodeConfig);
-
-		let offset = 0;
-		while (offset < totalFrames && !this.cancelled) {
-			const count = Math.min(OFFLINE_OUTPUT_FRAMES, totalFrames - offset);
-			// f32-planar layout: channel 0's `count` samples, then channel 1's, …
-			const planar = new Float32Array(count * channels);
-			for (let c = 0; c < channels; c++) {
-				planar.set(pcm[c].subarray(offset, offset + count), c * count);
-			}
-			const audioData = new AudioData({
-				format: "f32-planar",
-				sampleRate,
-				numberOfFrames: count,
-				numberOfChannels: channels,
-				timestamp: Math.round((offset / sampleRate) * 1_000_000),
-				data: planar.buffer as ArrayBuffer,
-			});
-			encoder.encode(audioData);
-			audioData.close();
-			offset += count;
-			while (encoder.encodeQueueSize > ENCODE_BACKPRESSURE_LIMIT && !this.cancelled) {
-				await new Promise((resolve) => setTimeout(resolve, 1));
-			}
-		}
-
-		if (encoder.state === "configured") {
-			await encoder.flush();
-			encoder.close();
-		}
-		for (const { chunk, meta } of encodedChunks) {
-			if (this.cancelled) break;
-			await muxer.addAudioChunk(chunk, meta);
-		}
-		console.log(`[AudioProcessor] Segmented audio: ${encodedChunks.length} chunks`);
-	}
-
-	cancel(): void {
-		this.cancelled = true;
-	}
-}
diff --git a/src/lib/exporter/cropSchedule.ts b/src/lib/exporter/cropSchedule.ts
new file mode 100644
index 0000000000..b6749ad58b
--- /dev/null
+++ b/src/lib/exporter/cropSchedule.ts
@@ -0,0 +1,26 @@
+// Per-clip crop lookup, shared by the GIF exporter and the document adapter.
+// Lived in videoExporter.ts until the web MP4 path was removed; GIF is the only
+// remaining renderer that resolves a crop off a timeline.
+
+import type { CropRegion } from "@/components/video-editor/types";
+
+export interface CropScheduleEntry {
+	startSec: number;
+	endSec: number;
+	cropRegion: CropRegion;
+}
+
+/** Finds which clip's crop applies at a given SOURCE-media timestamp — the
+ * first schedule entry whose [startSec, endSec) covers it, falling back to
+ * `fallback` when the schedule is absent or nothing covers it (e.g. a gap). */
+export function resolveCropAt(
+	schedule: CropScheduleEntry[] | undefined,
+	sourceSec: number,
+	fallback: CropRegion,
+): CropRegion {
+	if (!schedule || schedule.length === 0) return fallback;
+	const covering = schedule.find(
+		(entry) => sourceSec >= entry.startSec && sourceSec < entry.endSec,
+	);
+	return covering?.cropRegion ?? fallback;
+}
diff --git a/src/lib/exporter/gifExporter.ts b/src/lib/exporter/gifExporter.ts
index ce2df298d5..dbfb02179a 100644
--- a/src/lib/exporter/gifExporter.ts
+++ b/src/lib/exporter/gifExporter.ts
@@ -12,6 +12,7 @@ import type {
 import { BackgroundLoadError } from "@/lib/wallpaper";
 import type { CursorRecordingData } from "@/native/contracts";
 import { getPlatform } from "@/utils/platformUtils";
+import { type CropScheduleEntry, resolveCropAt } from "./cropSchedule";
 import { FrameRenderer } from "./frameRenderer";
 import { StreamingVideoDecoder } from "./streamingDecoder";
 import { TimestampedVideoFrameQueue } from "./timestampedVideoFrameQueue";
@@ -22,7 +23,6 @@ import type {
 	GifFrameRate,
 	GifSizePreset,
 } from "./types";
-import { type CropScheduleEntry, resolveCropAt } from "./videoExporter";
 
 const GIF_WORKER_URL = new URL("gif.js/dist/gif.worker.js", import.meta.url).toString();
 
diff --git a/src/lib/exporter/index.ts b/src/lib/exporter/index.ts
index 9d4f96d6f7..33cabd3a65 100644
--- a/src/lib/exporter/index.ts
+++ b/src/lib/exporter/index.ts
@@ -1,3 +1,4 @@
+export { type CropScheduleEntry, resolveCropAt } from "./cropSchedule";
 export { FrameRenderer } from "./frameRenderer";
 export { calculateOutputDimensions, GifExporter } from "./gifExporter";
 export {
@@ -5,7 +6,6 @@ export {
 	calculateMp4ExportSettings,
 	type Mp4ExportSettings,
 } from "./mp4ExportSettings";
-export { VideoMuxer } from "./muxer";
 export { StreamingVideoDecoder } from "./streamingDecoder";
 export type {
 	ExportConfig,
@@ -25,5 +25,3 @@ export {
 	isValidGifFrameRate,
 	VALID_GIF_FRAME_RATES,
 } from "./types";
-export { VideoFileDecoder } from "./videoDecoder";
-export { type CropScheduleEntry, resolveCropAt, VideoExporter } from "./videoExporter";
diff --git a/src/lib/exporter/muxer.ts b/src/lib/exporter/muxer.ts
deleted file mode 100644
index 6ac81d9bba..0000000000
--- a/src/lib/exporter/muxer.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import {
-	BufferTarget,
-	EncodedAudioPacketSource,
-	EncodedPacket,
-	EncodedVideoPacketSource,
-	Mp4OutputFormat,
-	Output,
-} from "mediabunny";
-import type { ExportConfig } from "./types";
-
-export type ExportAudioMuxerCodec = "aac" | "opus";
-
-// Map a WebCodecs codec string (e.g. "avc1.640033", "hvc1.1.6.L120.90",
-// "vp09.00.10.08") to its codec family.
-export function videoCodecFamily(codec: string | undefined): "avc" | "hevc" | "vp9" {
-	const lower = (codec ?? "").toLowerCase();
-	if (lower.startsWith("hvc1") || lower.startsWith("hev1")) return "hevc";
-	if (lower.startsWith("vp09") || lower.startsWith("vp9")) return "vp9";
-	return "avc";
-}
-
-export class VideoMuxer {
-	private output: Output | null = null;
-	private videoSource: EncodedVideoPacketSource | null = null;
-	private audioSource: EncodedAudioPacketSource | null = null;
-	private hasAudio: boolean;
-	private target: BufferTarget | null = null;
-	private config: ExportConfig;
-	private audioCodec: ExportAudioMuxerCodec;
-
-	constructor(config: ExportConfig, hasAudio = false, audioCodec: ExportAudioMuxerCodec = "aac") {
-		this.config = config;
-		this.hasAudio = hasAudio;
-		this.audioCodec = audioCodec;
-	}
-
-	async initialize(): Promise<void> {
-		this.target = new BufferTarget();
-
-		this.output = new Output({
-			format: new Mp4OutputFormat({
-				fastStart: "in-memory",
-			}),
-			target: this.target,
-		});
-
-		// Codec details are deduced from the chunk metadata; the family must
-		// match the encoder codec (F2.4 exposes h264/h265/vp9 in the dialog).
-		this.videoSource = new EncodedVideoPacketSource(videoCodecFamily(this.config.codec));
-		this.output.addVideoTrack(this.videoSource, {
-			frameRate: this.config.frameRate,
-		});
-
-		if (this.hasAudio) {
-			this.audioSource = new EncodedAudioPacketSource(this.audioCodec);
-			this.output.addAudioTrack(this.audioSource);
-		}
-
-		await this.output.start();
-	}
-
-	async addVideoChunk(chunk: EncodedVideoChunk, meta?: EncodedVideoChunkMetadata): Promise<void> {
-		if (!this.videoSource) {
-			throw new Error("Muxer not initialized");
-		}
-
-		const packet = EncodedPacket.fromEncodedChunk(chunk);
-
-		await this.videoSource.add(packet, meta);
-	}
-
-	async addAudioChunk(chunk: EncodedAudioChunk, meta?: EncodedAudioChunkMetadata): Promise<void> {
-		if (!this.audioSource) {
-			throw new Error("Audio not configured for this muxer");
-		}
-
-		const packet = EncodedPacket.fromEncodedChunk(chunk);
-
-		await this.audioSource.add(packet, meta);
-	}
-
-	async finalize(): Promise<Blob> {
-		if (!this.output || !this.target) {
-			throw new Error("Muxer not initialized");
-		}
-
-		await this.output.finalize();
-		const buffer = this.target.buffer;
-
-		if (!buffer) {
-			throw new Error("Failed to finalize output");
-		}
-
-		return new Blob([buffer], { type: "video/mp4" });
-	}
-}
diff --git a/src/lib/exporter/nativeFrameSink.test.ts b/src/lib/exporter/nativeFrameSink.test.ts
deleted file mode 100644
index 1a1d66a734..0000000000
--- a/src/lib/exporter/nativeFrameSink.test.ts
+++ /dev/null
@@ -1,202 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CREDIT_WINDOW, NativeFrameSink, type NativeSinkApi } from "./nativeFrameSink";
-
-/**
- * A stand-in for the main process: records frames, and only acks when told to,
- * so a test can hold the window full and observe the sender blocking.
- */
-function fakeMain(over: Partial<NativeSinkApi> = {}) {
-	let ack: ((sessionId: string, error: string | null) => void) | null = null;
-	const state = {
-		frames: [] as number[],
-		pending: [] as number[],
-		finished: false,
-		cancelled: false,
-		unsubscribed: false,
-		listenerAtFirstFrame: null as boolean | null,
-	};
-	const api: NativeSinkApi = {
-		exportStart: async () => ({ sessionId: "s1", encoder: "h264_amf" }),
-		exportWriteFrame: (_id, frame) => {
-			state.listenerAtFirstFrame ??= ack !== null;
-			state.frames.push(frame.byteLength);
-			state.pending.push(frame.byteLength);
-		},
-		exportOnFrameAck: (cb) => {
-			ack = cb;
-			return () => {
-				state.unsubscribed = true;
-			};
-		},
-		exportFinish: async () => {
-			state.finished = true;
-			return { outputPath: "/tmp/out.mp4" };
-		},
-		exportCancel: async () => {
-			state.cancelled = true;
-		},
-		...over,
-	};
-	/** Ack `n` frames as the main process would, one message each. */
-	const flush = (n = state.pending.length, error: string | null = null) => {
-		for (let i = 0; i < n; i++) {
-			state.pending.shift();
-			ack?.("s1", error);
-		}
-	};
-	/** Deliver an ack exactly as the main process would, for any session id. */
-	const ackAs = (sessionId: string, error: string | null = null) => ack?.(sessionId, error);
-	return { api, state, flush, ackAs };
-}
-
-const OPTS = {
-	outputPath: "/tmp/out.mp4",
-	width: 1920,
-	height: 1080,
-	frameRate: 60,
-	bitrate: 8_000_000,
-	pixelFormat: "nv12" as const,
-};
-
-/** Lets pending microtasks settle so a blocked write() can be observed as blocked. */
-const settle = () => new Promise((r) => setTimeout(r, 0));
-
-describe("NativeFrameSink", () => {
-	it("subscribes to acks before the first frame can be sent", async () => {
-		const { api, state } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-		await sink.write(new ArrayBuffer(16));
-		// If the listener were registered after the first send, an ack arriving
-		// promptly would be dropped and the window would never refill.
-		expect(state.listenerAtFirstFrame).toBe(true);
-	});
-
-	it("keeps exactly CREDIT_WINDOW frames in flight and blocks the next one", async () => {
-		const { api, state, flush } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-
-		for (let i = 0; i < CREDIT_WINDOW; i++) await sink.write(new ArrayBuffer(1));
-		expect(state.frames.length).toBe(CREDIT_WINDOW);
-
-		let sent = false;
-		const blocked = sink.write(new ArrayBuffer(1)).then(() => {
-			sent = true;
-		});
-		await settle();
-		// The window is full: this write must not have gone out.
-		expect(sent).toBe(false);
-		expect(state.frames.length).toBe(CREDIT_WINDOW);
-
-		flush(1);
-		await blocked;
-		expect(state.frames.length).toBe(CREDIT_WINDOW + 1);
-	});
-
-	it("does not block below the window — the whole point over stop-and-wait", async () => {
-		const { api, state } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-		// No acks at all: the first CREDIT_WINDOW writes must still all resolve.
-		for (let i = 0; i < CREDIT_WINDOW; i++) await sink.write(new ArrayBuffer(1));
-		expect(state.frames.length).toBe(CREDIT_WINDOW);
-	});
-
-	it("ignores acks addressed to another session", async () => {
-		const { api, state, ackAs } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-		for (let i = 0; i < CREDIT_WINDOW; i++) await sink.write(new ArrayBuffer(1));
-
-		let sent = false;
-		void sink.write(new ArrayBuffer(1)).then(() => {
-			sent = true;
-		});
-		// The ack channel is renderer-wide. A concurrent export's ack must not hand
-		// us a credit we did not earn, or we would overrun our own window.
-		ackAs("some-other-session");
-		await settle();
-		expect(sent).toBe(false);
-		expect(state.frames.length).toBe(CREDIT_WINDOW);
-
-		// Our own ack still works, proving the guard is on the id, not on everything.
-		ackAs("s1");
-		await settle();
-		expect(sent).toBe(true);
-	});
-
-	it("drains every in-flight frame before finishing", async () => {
-		const { api, state, flush } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-		for (let i = 0; i < 3; i++) await sink.write(new ArrayBuffer(1));
-
-		let done = false;
-		const finishing = sink.finish().then((r) => {
-			done = true;
-			return r;
-		});
-		await settle();
-		// Finishing with frames still in flight would close ffmpeg's stdin early
-		// and truncate the file.
-		expect(done).toBe(false);
-		expect(state.finished).toBe(false);
-
-		flush();
-		await expect(finishing).resolves.toEqual({ outputPath: "/tmp/out.mp4" });
-		expect(state.finished).toBe(true);
-	});
-
-	it("finishes immediately when nothing is in flight", async () => {
-		const { api } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-		await expect(sink.finish()).resolves.toEqual({ outputPath: "/tmp/out.mp4" });
-	});
-
-	it("unsubscribes from the ack channel on finish", async () => {
-		const { api, state } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-		await sink.finish();
-		expect(state.unsubscribed).toBe(true);
-	});
-
-	it("surfaces an ffmpeg write failure to the writer rather than hanging", async () => {
-		const { api, flush } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-		for (let i = 0; i < CREDIT_WINDOW; i++) await sink.write(new ArrayBuffer(1));
-
-		const blocked = sink.write(new ArrayBuffer(1));
-		flush(1, "ffmpeg exited: Cannot load nvcuda.dll");
-		// The parked write must reject, not resume: ffmpeg is gone.
-		await expect(blocked).rejects.toThrow(/nvcuda/);
-	});
-
-	it("reports the ffmpeg failure from finish() instead of the file it never wrote", async () => {
-		const { api, state, flush } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-		await sink.write(new ArrayBuffer(1));
-		flush(1, "ffmpeg died");
-		await expect(sink.finish()).rejects.toThrow(/ffmpeg died/);
-		// A dead session must be cancelled, not finished — finishing waits on a
-		// process that will never exit cleanly.
-		expect(state.finished).toBe(false);
-		expect(state.cancelled).toBe(true);
-	});
-
-	it("cancel() releases a writer parked on a credit that will never arrive", async () => {
-		const { api, state } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-		for (let i = 0; i < CREDIT_WINDOW; i++) await sink.write(new ArrayBuffer(1));
-
-		const blocked = sink.write(new ArrayBuffer(1));
-		await sink.cancel();
-		// Without the wake in cancel(), this write would hang forever and the
-		// export loop would never unwind.
-		await expect(blocked).rejects.toThrow(/closed/);
-		expect(state.cancelled).toBe(true);
-		expect(state.unsubscribed).toBe(true);
-	});
-
-	it("is idempotent on cancel", async () => {
-		const { api } = fakeMain();
-		const sink = await NativeFrameSink.start(OPTS, api);
-		await sink.cancel();
-		await expect(sink.cancel()).resolves.toBeUndefined();
-	});
-});
diff --git a/src/lib/exporter/nativeFrameSink.ts b/src/lib/exporter/nativeFrameSink.ts
deleted file mode 100644
index eb8b675d5d..0000000000
--- a/src/lib/exporter/nativeFrameSink.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-/**
- * Renderer side of the native export encoder: ships composited frames to the
- * main process, which feeds them to ffmpeg's stdin.
- *
- * Flow control is a credit window rather than stop-and-wait. Waiting for each
- * frame's ack before sending the next leaves the crossing idle for a full
- * round-trip per frame; keeping N frames in flight measured +56%. The window
- * saturates at 8 (32 adds nothing), because the crossing is bandwidth-bound —
- * IPC structured-clones every frame — not round-trip-bound.
- */
-
-/** Frames in flight. Measured: 8 saturates the crossing, 32 buys nothing. */
-export const CREDIT_WINDOW = 8;
-
-export interface NativeSinkApi {
-	exportStart: (req: unknown) => Promise<{
-		sessionId: string;
-		encoder: string;
-		outputPath: string;
-	}>;
-	exportWriteFrame: (sessionId: string, frame: ArrayBuffer) => void;
-	exportOnFrameAck: (cb: (sessionId: string, error: string | null) => void) => () => void;
-	exportFinish: (sessionId: string) => Promise<{ outputPath: string }>;
-	exportCancel: (sessionId: string) => Promise<void>;
-}
-
-export interface NativeSinkOptions {
-	/** Omitted: main writes to a temp file and reports the path back. */
-	outputPath?: string;
-	width: number;
-	height: number;
-	frameRate: number;
-	bitrate: number;
-	pixelFormat: "nv12" | "bgra" | "rgba";
-}
-
-export class NativeFrameSink {
-	private inFlight = 0;
-	private waiters: Array<() => void> = [];
-	private failure: Error | null = null;
-	private unsubscribe: (() => void) | null = null;
-	private closed = false;
-
-	private constructor(
-		private readonly api: NativeSinkApi,
-		private readonly sessionId: string,
-		readonly encoder: string,
-		readonly outputPath: string,
-	) {}
-
-	static async start(opts: NativeSinkOptions, api: NativeSinkApi): Promise<NativeFrameSink> {
-		const { sessionId, encoder, outputPath } = await api.exportStart(opts);
-		const sink = new NativeFrameSink(api, sessionId, encoder, outputPath);
-		// Subscribe before any frame goes out: an ack for frame 0 must not race the
-		// listener's registration, or the window never refills.
-		sink.unsubscribe = api.exportOnFrameAck((id, error) => sink.onAck(id, error));
-		return sink;
-	}
-
-	private onAck(sessionId: string, error: string | null): void {
-		// One renderer-wide ack channel: ignore other sessions' traffic.
-		if (sessionId !== this.sessionId) return;
-		if (error) this.failure ??= new Error(error);
-		this.inFlight--;
-		this.wake();
-	}
-
-	/** Resolve every waiter and let each re-check its own condition. */
-	private wake(): void {
-		const waiters = this.waiters;
-		this.waiters = [];
-		for (const resolve of waiters) resolve();
-	}
-
-	private block(): Promise<void> {
-		return new Promise<void>((resolve) => this.waiters.push(resolve));
-	}
-
-	/**
-	 * Ships one frame, blocking while the window is full.
-	 *
-	 * The buffer is handed to IPC, which copies it — the caller may reuse it as
-	 * soon as this returns.
-	 */
-	async write(frame: ArrayBuffer): Promise<void> {
-		if (this.failure) throw this.failure;
-		if (this.closed) throw new Error("Export sink is closed");
-		while (this.inFlight >= CREDIT_WINDOW) {
-			await this.block();
-			if (this.failure) throw this.failure;
-			if (this.closed) throw new Error("Export sink is closed");
-		}
-		this.inFlight++;
-		this.api.exportWriteFrame(this.sessionId, frame);
-	}
-
-	/** Waits for every in-flight frame to land, then closes ffmpeg's stdin. */
-	async finish(): Promise<{ outputPath: string }> {
-		if (this.closed) throw new Error("Export sink is closed");
-		while (this.inFlight > 0 && !this.failure) {
-			await this.block();
-		}
-		this.closed = true;
-		this.unsubscribe?.();
-		this.unsubscribe = null;
-		// ffmpeg is already dying on its own; surface why rather than the timeout
-		// that finishing a broken session would produce.
-		if (this.failure) {
-			await this.api.exportCancel(this.sessionId).catch(() => undefined);
-			throw this.failure;
-		}
-		return this.api.exportFinish(this.sessionId);
-	}
-
-	async cancel(): Promise<void> {
-		if (this.closed) return;
-		this.closed = true;
-		this.unsubscribe?.();
-		this.unsubscribe = null;
-		// Unblock anything parked on a credit: no further ack is coming.
-		this.wake();
-		await this.api.exportCancel(this.sessionId).catch(() => undefined);
-	}
-}
diff --git a/src/lib/exporter/perfTimings.test.ts b/src/lib/exporter/perfTimings.test.ts
deleted file mode 100644
index 9af186859b..0000000000
--- a/src/lib/exporter/perfTimings.test.ts
+++ /dev/null
@@ -1,174 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { StageTimings } from "./perfTimings";
-
-function fakeClock() {
-	let t = 0;
-	return {
-		now: () => t,
-		tick: (ms: number) => {
-			t += ms;
-		},
-	};
-}
-
-describe("StageTimings — record + snapshot", () => {
-	it("accumulates totals, counts, averages, and shares", () => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		timings.record("decode", 10);
-		timings.record("render", 30);
-		timings.record("decode", 20);
-
-		const snapshot = timings.snapshot();
-		expect(snapshot.totalMs).toBe(60);
-		expect(snapshot.stages.decode.totalMs).toBe(30);
-		expect(snapshot.stages.decode.count).toBe(2);
-		expect(snapshot.stages.decode.avgMs).toBe(15);
-		expect(snapshot.stages.decode.pct).toBe(50);
-		expect(snapshot.stages.render.totalMs).toBe(30);
-		expect(snapshot.stages.render.count).toBe(1);
-		expect(snapshot.stages.render.avgMs).toBe(30);
-		expect(snapshot.stages.render.pct).toBe(50);
-		expect(Object.values(snapshot.stages).reduce((sum, stat) => sum + stat.pct, 0)).toBeCloseTo(
-			100,
-		);
-	});
-
-	it("preserves first-seen order in snapshots and summaries", () => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		timings.record("render", 2);
-		timings.record("decode-wait", 1);
-		timings.record("render", 3);
-		timings.record("encode-wait", 4);
-
-		expect(Object.keys(timings.snapshot().stages)).toEqual([
-			"render",
-			"decode-wait",
-			"encode-wait",
-		]);
-
-		const rows = timings
-			.formatSummary()
-			.split("\n")
-			.filter(
-				(line) =>
-					line.startsWith("render") ||
-					line.startsWith("decode-wait") ||
-					line.startsWith("encode-wait"),
-			);
-		expect(rows.map((row) => row.trimStart().split(/\s+/)[0])).toEqual([
-			"render",
-			"decode-wait",
-			"encode-wait",
-		]);
-	});
-});
-
-describe("StageTimings — injected-clock helpers", () => {
-	it("records a start/stop duration once", () => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		const stop = timings.start("x");
-		clock.tick(10);
-		stop();
-		stop();
-
-		expect(timings.snapshot().stages.x).toEqual({ totalMs: 10, count: 1, avgMs: 10, pct: 100 });
-	});
-
-	it("times a synchronous function and returns its result", () => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		const result = timings.time("x", () => {
-			clock.tick(12);
-			return 42;
-		});
-
-		expect(result).toBe(42);
-		expect(timings.snapshot().stages.x.totalMs).toBe(12);
-	});
-
-	it("times an async function and returns its resolved value", async () => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		const result = await timings.timeAsync("x", async () => {
-			clock.tick(18);
-			return "done";
-		});
-
-		expect(result).toBe("done");
-		expect(timings.snapshot().stages.x).toEqual({ totalMs: 18, count: 1, avgMs: 18, pct: 100 });
-	});
-
-	it("records async elapsed time when the function rejects and re-throws", async () => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		const error = new Error("failed");
-
-		await expect(
-			timings.timeAsync("reject", async () => {
-				clock.tick(7);
-				throw error;
-			}),
-		).rejects.toBe(error);
-
-		expect(timings.snapshot().stages.reject).toEqual({ totalMs: 7, count: 1, avgMs: 7, pct: 100 });
-	});
-});
-
-describe("StageTimings — invalid and empty samples", () => {
-	it.each([
-		["negative", -1],
-		["NaN", Number.NaN],
-		["Infinity", Number.POSITIVE_INFINITY],
-	])("ignores a %s duration without creating a sample", (_name, duration) => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		timings.record("bad", duration);
-
-		expect(timings.snapshot()).toEqual({ stages: {}, totalMs: 0 });
-	});
-
-	it("reports zero averages and shares for empty timings and a zero-duration sample", () => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		expect(timings.snapshot()).toEqual({ stages: {}, totalMs: 0 });
-
-		timings.record("zero", 0);
-		expect(timings.snapshot().stages.zero).toEqual({ totalMs: 0, count: 1, avgMs: 0, pct: 0 });
-	});
-});
-
-describe("StageTimings — formatSummary and reset", () => {
-	it("formats stage rows, a total, effective fps, and hardware acceleration", () => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		timings.record("decode-wait", 10);
-		timings.record("render", 10);
-
-		const summary = timings.formatSummary({ frames: 10, hardwareAcceleration: "prefer-hardware" });
-		expect(summary).toContain("decode-wait");
-		expect(summary).toContain("render");
-		expect(summary).toContain("TOTAL");
-		expect(summary).toContain("fps: 500.0");
-		expect(summary).toContain("hwAccel: prefer-hardware");
-	});
-
-	it("uses n/a for fps when total time is zero", () => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		timings.record("zero", 0);
-
-		expect(timings.formatSummary({ frames: 10 })).toContain("fps: n/a");
-	});
-
-	it("clears all accumulated timing data", () => {
-		const clock = fakeClock();
-		const timings = new StageTimings(clock.now);
-		timings.record("x", 25);
-		timings.reset();
-
-		expect(timings.snapshot()).toEqual({ stages: {}, totalMs: 0 });
-	});
-});
diff --git a/src/lib/exporter/perfTimings.ts b/src/lib/exporter/perfTimings.ts
deleted file mode 100644
index 7bf46049bc..0000000000
--- a/src/lib/exporter/perfTimings.ts
+++ /dev/null
@@ -1,138 +0,0 @@
-// StageTimings: pure-logic per-stage timing accumulation for the v2 export
-// performance harness. Callers provide measured durations or wrap work with an
-// injected clock; this module does not time export work or touch browser APIs.
-
-export interface StageStat {
-	totalMs: number; // summed elapsed across all record()/stop() calls for this stage
-	count: number; // number of samples
-	avgMs: number; // totalMs / count (0 when count === 0)
-	pct: number; // totalMs / grandTotalMs * 100 (0 when grandTotal === 0)
-}
-
-export interface PerfSnapshot {
-	stages: Record<string, StageStat>; // keyed by stage name, in FIRST-SEEN order
-	totalMs: number; // sum of every stage's totalMs
-}
-
-interface MutableStageStat {
-	totalMs: number;
-	count: number;
-}
-
-const defaultNow =
-	typeof performance !== "undefined" && typeof performance.now === "function"
-		? () => performance.now()
-		: () => Date.now();
-
-export class StageTimings {
-	private readonly now: () => number;
-
-	private readonly stats = new Map<string, MutableStageStat>();
-
-	constructor(now: () => number = defaultNow) {
-		this.now = now;
-	}
-
-	record(stage: string, ms: number): void {
-		if (!Number.isFinite(ms) || ms < 0) {
-			// Invalid durations are skipped so they do not create a misleading sample.
-			return;
-		}
-
-		const stat = this.stats.get(stage);
-		if (stat) {
-			stat.totalMs += ms;
-			stat.count += 1;
-			return;
-		}
-
-		this.stats.set(stage, { totalMs: ms, count: 1 });
-	}
-
-	start(stage: string): () => void {
-		const startedAt = this.now();
-		let stopped = false;
-
-		return () => {
-			if (stopped) {
-				return;
-			}
-			stopped = true;
-			this.record(stage, Math.max(0, this.now() - startedAt));
-		};
-	}
-
-	time<T>(stage: string, fn: () => T): T {
-		const stop = this.start(stage);
-		try {
-			return fn();
-		} finally {
-			stop();
-		}
-	}
-
-	async timeAsync<T>(stage: string, fn: () => Promise<T>): Promise<T> {
-		const stop = this.start(stage);
-		try {
-			return await fn();
-		} finally {
-			stop();
-		}
-	}
-
-	snapshot(): PerfSnapshot {
-		let totalMs = 0;
-		for (const stat of this.stats.values()) {
-			totalMs += stat.totalMs;
-		}
-
-		const stages: Record<string, StageStat> = {};
-		for (const [stage, stat] of this.stats) {
-			stages[stage] = {
-				totalMs: stat.totalMs,
-				count: stat.count,
-				avgMs: stat.count === 0 ? 0 : stat.totalMs / stat.count,
-				pct: totalMs === 0 ? 0 : (stat.totalMs / totalMs) * 100,
-			};
-		}
-
-		return { stages, totalMs };
-	}
-
-	formatSummary(opts: { frames?: number; hardwareAcceleration?: string } = {}): string {
-		const snapshot = this.snapshot();
-		const lines = ["stage      totalMs    pct    avgMs  count"];
-
-		for (const [stage, stat] of Object.entries(snapshot.stages)) {
-			lines.push(
-				`${stage}  ${stat.totalMs.toFixed(1).padStart(9)}  ${stat.pct
-					.toFixed(1)
-					.padStart(5)}%  ${stat.avgMs.toFixed(2).padStart(7)}  n=${stat.count}`,
-			);
-		}
-
-		const totalCount = Object.values(snapshot.stages).reduce((sum, stat) => sum + stat.count, 0);
-		const totalAvgMs = totalCount === 0 ? 0 : snapshot.totalMs / totalCount;
-		const totalPct = snapshot.totalMs === 0 ? 0 : 100;
-		lines.push(
-			`TOTAL      ${snapshot.totalMs.toFixed(1).padStart(9)}  ${totalPct
-				.toFixed(1)
-				.padStart(5)}%  ${totalAvgMs.toFixed(2).padStart(7)}  n=${totalCount}`,
-		);
-
-		if (opts.frames !== undefined) {
-			const fps =
-				snapshot.totalMs === 0 ? "n/a" : (opts.frames / (snapshot.totalMs / 1000)).toFixed(1);
-			lines.push(`fps: ${fps}`);
-		}
-		if (opts.hardwareAcceleration !== undefined) {
-			lines.push(`hwAccel: ${opts.hardwareAcceleration}`);
-		}
-
-		return lines.join("\n");
-	}
-
-	reset(): void {
-		this.stats.clear();
-	}
-}
diff --git a/src/lib/exporter/planarChunkQueue.test.ts b/src/lib/exporter/planarChunkQueue.test.ts
deleted file mode 100644
index b1da7a4070..0000000000
--- a/src/lib/exporter/planarChunkQueue.test.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { PlanarChunkQueue } from "./planarChunkQueue";
-
-function ramp(from: number, count: number): Float32Array {
-	const a = new Float32Array(count);
-	for (let i = 0; i < count; i++) a[i] = from + i;
-	return a;
-}
-
-describe("PlanarChunkQueue", () => {
-	it("tracks buffered length across pushes and takes", () => {
-		const q = new PlanarChunkQueue(1);
-		expect(q.length).toBe(0);
-		q.push([ramp(0, 10)], 10);
-		q.push([ramp(10, 5)], 5);
-		expect(q.length).toBe(15);
-		q.take(6);
-		expect(q.length).toBe(9);
-	});
-
-	it("drains samples in FIFO order across chunk boundaries (mono)", () => {
-		const q = new PlanarChunkQueue(1);
-		q.push([ramp(0, 4)], 4); // 0..3
-		q.push([ramp(4, 4)], 4); // 4..7
-		q.push([ramp(8, 4)], 4); // 8..11
-		// A take that spans multiple chunks and stops mid-chunk.
-		expect(Array.from(q.take(5))).toEqual([0, 1, 2, 3, 4]);
-		expect(Array.from(q.take(5))).toEqual([5, 6, 7, 8, 9]);
-		expect(Array.from(q.take(2))).toEqual([10, 11]);
-		expect(q.length).toBe(0);
-	});
-
-	it("keeps channels separate and lays them out planar [ch0…, ch1…]", () => {
-		const q = new PlanarChunkQueue(2);
-		q.push([ramp(0, 3), ramp(100, 3)], 3); // L:0,1,2  R:100,101,102
-		q.push([ramp(3, 3), ramp(103, 3)], 3); // L:3,4,5  R:103,104,105
-		const out = q.take(4);
-		// First 4 = left, next 4 = right.
-		expect(Array.from(out.subarray(0, 4))).toEqual([0, 1, 2, 3]);
-		expect(Array.from(out.subarray(4, 8))).toEqual([100, 101, 102, 103]);
-		expect(q.length).toBe(2);
-		const rest = q.take(2);
-		expect(Array.from(rest.subarray(0, 2))).toEqual([4, 5]);
-		expect(Array.from(rest.subarray(2, 4))).toEqual([104, 105]);
-	});
-
-	it("honors a partial chunk consumed by an earlier take before dropping it", () => {
-		const q = new PlanarChunkQueue(1);
-		q.push([ramp(0, 10)], 10);
-		expect(Array.from(q.take(3))).toEqual([0, 1, 2]); // leaves headOffset=3 in chunk 0
-		q.push([ramp(10, 3)], 3);
-		expect(Array.from(q.take(9))).toEqual([3, 4, 5, 6, 7, 8, 9, 10, 11]);
-		expect(q.length).toBe(1);
-		expect(Array.from(q.take(1))).toEqual([12]);
-	});
-
-	it("ignores non-positive pushes/takes", () => {
-		const q = new PlanarChunkQueue(1);
-		q.push([ramp(0, 5)], 0);
-		expect(q.length).toBe(0);
-		expect(Array.from(q.take(0))).toEqual([]);
-	});
-
-	it("reconstructs a long stream fed in odd-sized chunks and drained in fixed slices", () => {
-		const q = new PlanarChunkQueue(1);
-		const total = 5000;
-		let produced = 0;
-		const collected: number[] = [];
-		// Feed odd chunk sizes, drain 512 whenever enough is buffered.
-		for (let chunk = 1; produced < total; chunk++) {
-			const n = Math.min(chunk, total - produced);
-			q.push([ramp(produced, n)], n);
-			produced += n;
-			while (q.length >= 512) collected.push(...q.take(512));
-		}
-		while (q.length > 0) collected.push(...q.take(Math.min(512, q.length)));
-		expect(collected.length).toBe(total);
-		expect(collected[0]).toBe(0);
-		expect(collected[total - 1]).toBe(total - 1);
-		// Strictly increasing ⇒ no reorder/drop/dupe.
-		expect(collected.every((v, i) => v === i)).toBe(true);
-	});
-});
diff --git a/src/lib/exporter/planarChunkQueue.ts b/src/lib/exporter/planarChunkQueue.ts
deleted file mode 100644
index d0d9b40182..0000000000
--- a/src/lib/exporter/planarChunkQueue.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-// FIFO queue of planar PCM chunks with O(1) amortized append and front-drain.
-//
-// The offline audio time-stretch path produces output in many small chunks and
-// drains fixed-size slices to the encoder. A grow-and-copy accumulator would be
-// O(N^2) over a long run; this keeps each chunk by reference and only copies the
-// samples that are actually pulled out (O(take) per drain, O(total) overall).
-
-export class PlanarChunkQueue {
-	private readonly channels: number;
-	private readonly queue: Float32Array[][];
-	private headOffset = 0; // consumed samples into queue[*][0] (shared across channels)
-	private queuedLen = 0;
-
-	constructor(channels: number) {
-		this.channels = Math.max(1, channels);
-		this.queue = Array.from({ length: this.channels }, () => []);
-	}
-
-	/** Samples currently buffered (per channel). */
-	get length(): number {
-		return this.queuedLen;
-	}
-
-	/** Append the first `count` samples of each channel plane (stored by reference). */
-	push(planes: Float32Array[], count: number): void {
-		if (count <= 0) return;
-		for (let c = 0; c < this.channels; c++) {
-			this.queue[c].push((planes[c] ?? planes[0]).subarray(0, count));
-		}
-		this.queuedLen += count;
-	}
-
-	/**
-	 * Remove `take` samples from the front and return them as one planar buffer laid
-	 * out [ch0 samples…, ch1 samples…, …]. `take` must be ≤ length.
-	 */
-	take(take: number): Float32Array {
-		if (take <= 0) return new Float32Array(0);
-		const data = new Float32Array(take * this.channels);
-		for (let c = 0; c < this.channels; c++) {
-			let need = take;
-			let ci = 0;
-			let off = this.headOffset;
-			let dst = c * take;
-			while (need > 0) {
-				const chunk = this.queue[c][ci];
-				const avail = chunk.length - off;
-				const n = avail < need ? avail : need;
-				data.set(chunk.subarray(off, off + n), dst);
-				dst += n;
-				need -= n;
-				if (n < avail) {
-					off += n;
-				} else {
-					ci += 1;
-					off = 0;
-				}
-			}
-		}
-		// Advance the shared head / drop fully consumed chunks (identical layout per channel).
-		let remaining = take;
-		while (remaining > 0) {
-			const avail = this.queue[0][0].length - this.headOffset;
-			if (avail <= remaining) {
-				for (let c = 0; c < this.channels; c++) this.queue[c].shift();
-				this.headOffset = 0;
-				remaining -= avail;
-			} else {
-				this.headOffset += remaining;
-				remaining = 0;
-			}
-		}
-		this.queuedLen -= take;
-		return data;
-	}
-}
diff --git a/src/lib/exporter/videoDecoder.ts b/src/lib/exporter/videoDecoder.ts
deleted file mode 100644
index 505e94f2e8..0000000000
--- a/src/lib/exporter/videoDecoder.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-export interface DecodedVideoInfo {
-	width: number;
-	height: number;
-	duration: number; // in seconds
-	frameRate: number;
-	codec: string;
-}
-
-export class VideoFileDecoder {
-	private info: DecodedVideoInfo | null = null;
-	private videoElement: HTMLVideoElement | null = null;
-
-	async loadVideo(videoUrl: string): Promise<DecodedVideoInfo> {
-		this.videoElement = document.createElement("video");
-		this.videoElement.src = videoUrl;
-		this.videoElement.preload = "metadata";
-
-		return new Promise((resolve, reject) => {
-			this.videoElement!.addEventListener("loadedmetadata", () => {
-				const video = this.videoElement!;
-
-				this.info = {
-					width: video.videoWidth,
-					height: video.videoHeight,
-					duration: video.duration,
-					frameRate: 60,
-					codec: "avc1.640033",
-				};
-
-				resolve(this.info);
-			});
-
-			this.videoElement!.addEventListener("error", (e) => {
-				reject(new Error(`Failed to load video: ${e}`));
-			});
-		});
-	}
-
-	/** The underlying video element, used for seeking. */
-	getVideoElement(): HTMLVideoElement | null {
-		return this.videoElement;
-	}
-
-	getInfo(): DecodedVideoInfo | null {
-		return this.info;
-	}
-
-	destroy(): void {
-		if (this.videoElement) {
-			this.videoElement.pause();
-			this.videoElement.src = "";
-			this.videoElement = null;
-		}
-	}
-}
diff --git a/src/lib/exporter/videoExporter.browser.test.ts b/src/lib/exporter/videoExporter.browser.test.ts
deleted file mode 100644
index cca896ff82..0000000000
--- a/src/lib/exporter/videoExporter.browser.test.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import { describe, expect, it } from "vitest";
-import sampleVideoUrl from "../../../tests/fixtures/sample.webm?url";
-import { BackgroundLoadError } from "../wallpaper";
-import type { ExportProgress } from "./types";
-import { VideoExporter } from "./videoExporter";
-
-describe("VideoExporter (real browser)", () => {
-	it("exports a valid MP4 blob from a real video", async () => {
-		const progressEvents: ExportProgress[] = [];
-
-		const exporter = new VideoExporter({
-			videoUrl: sampleVideoUrl,
-			width: 320,
-			height: 180,
-			frameRate: 15,
-			bitrate: 1_000_000,
-			wallpaper: "#1a1a2e",
-			zoomRegions: [],
-			showShadow: false,
-			shadowIntensity: 0,
-			showBlur: false,
-			cropRegion: { x: 0, y: 0, width: 1, height: 1 },
-			onProgress: (p) => progressEvents.push(p),
-		});
-
-		const result = await exporter.export();
-
-		expect(result.success, result.error).toBe(true);
-		expect(result.blob).toBeInstanceOf(Blob);
-
-		const buf = await result.blob!.arrayBuffer();
-		const bytes = new Uint8Array(buf);
-		const ftyp = new TextDecoder().decode(bytes.slice(4, 8));
-		expect(ftyp).toBe("ftyp");
-
-		expect(result.blob!.size).toBeGreaterThan(1024);
-
-		expect(progressEvents.length).toBeGreaterThan(0);
-
-		const finalizing = progressEvents.filter((p) => p.phase === "finalizing");
-		expect(finalizing.length).toBeGreaterThan(0);
-		expect(finalizing.at(-1)!.percentage).toBe(100);
-	});
-
-	it("exports successfully with an image wallpaper (served by Vite dev server)", async () => {
-		const exporter = new VideoExporter({
-			videoUrl: sampleVideoUrl,
-			width: 320,
-			height: 180,
-			frameRate: 15,
-			bitrate: 1_000_000,
-			wallpaper: "/wallpapers/wallpaper1.jpg",
-			zoomRegions: [],
-			showShadow: false,
-			shadowIntensity: 0,
-			showBlur: false,
-			cropRegion: { x: 0, y: 0, width: 1, height: 1 },
-		});
-
-		const result = await exporter.export();
-		expect(result.success, result.error).toBe(true);
-		expect(result.blob!.size).toBeGreaterThan(1024);
-	});
-
-	it("throws BackgroundLoadError when wallpaper fails to load (no silent black fallback)", async () => {
-		const exporter = new VideoExporter({
-			videoUrl: sampleVideoUrl,
-			width: 320,
-			height: 180,
-			frameRate: 15,
-			bitrate: 1_000_000,
-			wallpaper: "/wallpapers/does-not-exist.jpg",
-			zoomRegions: [],
-			showShadow: false,
-			shadowIntensity: 0,
-			showBlur: false,
-			cropRegion: { x: 0, y: 0, width: 1, height: 1 },
-		});
-
-		const rejection = exporter.export();
-		await expect(rejection).rejects.toBeInstanceOf(BackgroundLoadError);
-		await expect(rejection).rejects.toMatchObject({
-			url: expect.stringContaining("does-not-exist"),
-		});
-	});
-});
diff --git a/src/lib/exporter/videoExporter.test.ts b/src/lib/exporter/videoExporter.test.ts
deleted file mode 100644
index 61dad9f72f..0000000000
--- a/src/lib/exporter/videoExporter.test.ts
+++ /dev/null
@@ -1,311 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import {
-	getSourceCopyFastPathBlockers,
-	isSourceCopyFastPathEligible,
-	resolveCropAt,
-	type VideoExporterConfig,
-	waitForEncoderQueueSpace,
-} from "./videoExporter";
-
-function createConfig(overrides: Partial<VideoExporterConfig> = {}): VideoExporterConfig {
-	return {
-		videoUrl: "recording.mp4",
-		width: 1920,
-		height: 1080,
-		frameRate: 60,
-		bitrate: 30_000_000,
-		wallpaper: "#000000",
-		zoomRegions: [],
-		trimRegions: [],
-		speedRegions: [],
-		showShadow: false,
-		shadowIntensity: 0,
-		showBlur: false,
-		cropRegion: { x: 0, y: 0, width: 1, height: 1 },
-		...overrides,
-	};
-}
-
-describe("isSourceCopyFastPathEligible", () => {
-	it("allows a no-op MP4 export at source dimensions", () => {
-		expect(
-			isSourceCopyFastPathEligible(createConfig(), {
-				width: 1920,
-				height: 1080,
-				frameRate: 60,
-				codec: "avc1.640033",
-			}),
-		).toBe(true);
-	});
-
-	it("rejects a frame rate or codec that differs from the source", () => {
-		const videoInfo = { width: 1920, height: 1080, frameRate: 60, codec: "avc1.640033" };
-
-		expect(isSourceCopyFastPathEligible(createConfig({ frameRate: 30 }), videoInfo)).toBe(false);
-		expect(
-			isSourceCopyFastPathEligible(createConfig({ codec: "hvc1.1.6.L120.90" }), videoInfo),
-		).toBe(false);
-		// A container-rounded rate (59.94 vs the nominal 60) shouldn't force a
-		// re-encode on its own.
-		expect(isSourceCopyFastPathEligible(createConfig(), { ...videoInfo, frameRate: 59.94 })).toBe(
-			true,
-		);
-	});
-
-	it("rejects timeline edits and frame-level effects", () => {
-		const videoInfo = { width: 1920, height: 1080, frameRate: 60, codec: "avc1.640033" };
-
-		expect(
-			isSourceCopyFastPathEligible(
-				createConfig({ trimRegions: [{ id: "trim", startMs: 100, endMs: 200 }] }),
-				videoInfo,
-			),
-		).toBe(false);
-		expect(
-			isSourceCopyFastPathEligible(
-				createConfig({
-					speedRegions: [{ id: "speed", startMs: 100, endMs: 200, speed: 1.5 }],
-				}),
-				videoInfo,
-			),
-		).toBe(false);
-		// A 100× region must also block the copy path (any non-1× speed does), so its
-		// audio is re-rendered (offline time-stretch) rather than passed through untouched.
-		expect(
-			isSourceCopyFastPathEligible(
-				createConfig({
-					speedRegions: [{ id: "speed", startMs: 100, endMs: 200, speed: 100 }],
-				}),
-				videoInfo,
-			),
-		).toBe(false);
-		expect(
-			isSourceCopyFastPathEligible(
-				createConfig({
-					zoomRegions: [
-						{
-							id: "zoom",
-							startMs: 100,
-							endMs: 200,
-							depth: 2,
-							focus: { cx: 0.5, cy: 0.5 },
-						},
-					],
-				}),
-				videoInfo,
-			),
-		).toBe(false);
-		expect(isSourceCopyFastPathEligible(createConfig({ showBlur: true }), videoInfo)).toBe(false);
-	});
-
-	it("rejects resizing and overlays", () => {
-		const videoInfo = { width: 1920, height: 1080, frameRate: 60, codec: "avc1.640033" };
-
-		expect(isSourceCopyFastPathEligible(createConfig({ width: 1280 }), videoInfo)).toBe(false);
-		expect(
-			isSourceCopyFastPathEligible(
-				createConfig({
-					cursorScale: 2,
-				}),
-				videoInfo,
-			),
-		).toBe(false);
-		expect(
-			isSourceCopyFastPathEligible(
-				createConfig({
-					cursorScale: 2,
-					cursorRecordingData: {
-						version: 2,
-						provider: "native",
-						assets: [
-							{
-								id: "cursor",
-								platform: "win32",
-								imageDataUrl: "data:image/png;base64,AA==",
-								width: 32,
-								height: 32,
-								hotspotX: 0,
-								hotspotY: 0,
-							},
-						],
-						samples: [{ timeMs: 0, cx: 0.5, cy: 0.5, visible: true, assetId: "cursor" }],
-					},
-				}),
-				videoInfo,
-			),
-		).toBe(false);
-	});
-});
-
-describe("getSourceCopyFastPathBlockers", () => {
-	it("reports the source-size mismatch that blocks copy-only export", () => {
-		expect(
-			getSourceCopyFastPathBlockers(createConfig({ height: 1080 }), {
-				width: 1920,
-				height: 1032,
-				frameRate: 60,
-				codec: "avc1.640033",
-			}),
-		).toContain("output-size 1920x1080 differs from source 1920x1032");
-	});
-
-	it("blocks the fast path when any clip in the crop schedule has a non-default crop", () => {
-		const videoInfo = { width: 1920, height: 1080, frameRate: 60, codec: "avc1.640033" };
-		const blockers = getSourceCopyFastPathBlockers(
-			createConfig({
-				cropSchedule: [
-					{ startSec: 0, endSec: 3, cropRegion: { x: 0, y: 0, width: 1, height: 1 } },
-					{ startSec: 3, endSec: 6, cropRegion: { x: 0.25, y: 0.25, width: 0.5, height: 0.5 } },
-				],
-			}),
-			videoInfo,
-		);
-		expect(blockers).toContain("crop is not default");
-	});
-
-	it("allows the fast path when every clip in the crop schedule is default", () => {
-		const videoInfo = { width: 1920, height: 1080, frameRate: 60, codec: "avc1.640033" };
-		const blockers = getSourceCopyFastPathBlockers(
-			createConfig({
-				cropSchedule: [
-					{ startSec: 0, endSec: 3, cropRegion: { x: 0, y: 0, width: 1, height: 1 } },
-					{ startSec: 3, endSec: 6, cropRegion: { x: 0, y: 0, width: 1, height: 1 } },
-				],
-			}),
-			videoInfo,
-		);
-		expect(blockers).not.toContain("crop is not default");
-	});
-});
-
-describe("resolveCropAt", () => {
-	const identity = { x: 0, y: 0, width: 1, height: 1 };
-	const halfCrop = { x: 0.25, y: 0.25, width: 0.5, height: 0.5 };
-	const schedule = [
-		{ startSec: 0, endSec: 3, cropRegion: halfCrop },
-		{ startSec: 3, endSec: 6, cropRegion: identity },
-	];
-
-	it("picks the schedule entry covering the given source time", () => {
-		expect(resolveCropAt(schedule, 1.5, identity)).toBe(halfCrop);
-		expect(resolveCropAt(schedule, 4, identity)).toBe(identity);
-	});
-
-	it("treats entry end as exclusive so back-to-back clips don't overlap", () => {
-		expect(resolveCropAt(schedule, 3, identity)).toBe(identity);
-	});
-
-	it("falls back when nothing covers the timestamp or the schedule is absent", () => {
-		const fallback = { x: 0.1, y: 0.1, width: 0.8, height: 0.8 };
-		expect(resolveCropAt(schedule, 10, fallback)).toBe(fallback);
-		expect(resolveCropAt(undefined, 1.5, fallback)).toBe(fallback);
-		expect(resolveCropAt([], 1.5, fallback)).toBe(fallback);
-	});
-});
-
-// The original bug measured the timeout from the encoder's last *output* event
-// (lastEncoderOutputAt), which went stale while the decoder discarded frames inside
-// a trim region. waitForEncoderQueueSpace fixes this by starting the clock fresh on
-// each call instead of accepting any such external timestamp — by construction, there
-// is no "last output" state to go stale, so that regression can't be reintroduced
-// without changing this function's signature.
-describe("waitForEncoderQueueSpace", () => {
-	function fakeClock(start = 0) {
-		let elapsedMs = start;
-		return {
-			now: () => elapsedMs,
-			sleep: async (ms: number) => {
-				elapsedMs += ms;
-			},
-		};
-	}
-
-	it("resolves immediately when the queue already has space", async () => {
-		const clock = fakeClock();
-		const sleep = vi.fn(clock.sleep);
-
-		await waitForEncoderQueueSpace({
-			getQueueSize: () => 0,
-			maxEncodeQueue: 8,
-			isCancelled: () => false,
-			encoderPreference: "prefer-hardware",
-			now: clock.now,
-			sleep,
-		});
-
-		expect(sleep).not.toHaveBeenCalled();
-	});
-
-	it("waits for the queue to drain and then resolves", async () => {
-		const clock = fakeClock();
-		let queueSize = 8;
-		// Queue drains well within the timeout.
-		const sleep = vi.fn(async (ms: number) => {
-			await clock.sleep(ms);
-			queueSize = 0;
-		});
-
-		await waitForEncoderQueueSpace({
-			getQueueSize: () => queueSize,
-			maxEncodeQueue: 8,
-			isCancelled: () => false,
-			encoderPreference: "prefer-hardware",
-			now: clock.now,
-			sleep,
-		});
-
-		expect(sleep).toHaveBeenCalledTimes(1);
-	});
-
-	it("throws a hardware-specific error once the queue stays full past the timeout", async () => {
-		const clock = fakeClock();
-
-		await expect(
-			waitForEncoderQueueSpace({
-				getQueueSize: () => 8,
-				maxEncodeQueue: 8,
-				isCancelled: () => false,
-				encoderPreference: "prefer-hardware",
-				now: clock.now,
-				sleep: clock.sleep,
-			}),
-		).rejects.toThrow(
-			"The hardware video encoder stopped responding. Retrying with a safer encoder.",
-		);
-	});
-
-	it("throws a generic error for the software encoder once the queue stays full past the timeout", async () => {
-		const clock = fakeClock();
-
-		await expect(
-			waitForEncoderQueueSpace({
-				getQueueSize: () => 8,
-				maxEncodeQueue: 8,
-				isCancelled: () => false,
-				encoderPreference: "prefer-software",
-				now: clock.now,
-				sleep: clock.sleep,
-			}),
-		).rejects.toThrow("The video encoder stopped responding during export.");
-	});
-
-	it("stops waiting without throwing once cancelled", async () => {
-		const clock = fakeClock();
-		let cancelled = false;
-		const sleep = vi.fn(async (ms: number) => {
-			await clock.sleep(ms);
-			cancelled = true;
-		});
-
-		await expect(
-			waitForEncoderQueueSpace({
-				getQueueSize: () => 8,
-				maxEncodeQueue: 8,
-				isCancelled: () => cancelled,
-				encoderPreference: "prefer-hardware",
-				now: clock.now,
-				sleep,
-			}),
-		).resolves.toBeUndefined();
-	});
-});
diff --git a/src/lib/exporter/videoExporter.ts b/src/lib/exporter/videoExporter.ts
deleted file mode 100644
index 484c81a8d1..0000000000
--- a/src/lib/exporter/videoExporter.ts
+++ /dev/null
@@ -1,2024 +0,0 @@
-import type {
-	AnnotationRegion,
-	CameraFullscreenRegion,
-	CropRegion,
-	SpeedRegion,
-	TrimRegion,
-	WebcamLayoutPreset,
-	WebcamSizePreset,
-	ZoomRegion,
-} from "@/components/video-editor/types";
-import { assembleConcatenatedPcm } from "@/lib/ai-edition/exporter/audioConcatAssembler";
-import { buildAudioConcatPlan } from "@/lib/ai-edition/exporter/audioConcatPlan";
-import type { RenderPlan, RenderSegment } from "@/lib/ai-edition/exporter/renderPlan";
-import { BackgroundLoadError } from "@/lib/wallpaper";
-import type { CursorRecordingData } from "@/native/contracts";
-import { getPlatform } from "@/utils/platformUtils";
-import { AudioProcessor, downmixPlanarChannelsForExport } from "./audioEncoder";
-import { WsolaTimeStretcher } from "./audioTimeStretch";
-import { CanvasFrameExtractor } from "./frameExtract";
-import { FrameRenderer } from "./frameRenderer";
-import { materializeLocalSourceFile, releaseLocalSourceFile } from "./localSourceFile";
-import { VideoMuxer, videoCodecFamily } from "./muxer";
-import { NativeFrameSink, type NativeSinkApi } from "./nativeFrameSink";
-import { StageTimings } from "./perfTimings";
-import { MAX_IN_MEMORY_SOURCE_BYTES } from "./sourceFileLimits";
-import { StreamingVideoDecoder } from "./streamingDecoder";
-import { computeKeepSegments, splitBySpeed } from "./timelineSegments";
-import { TimestampedVideoFrameQueue } from "./timestampedVideoFrameQueue";
-import type { ExportConfig, ExportProgress, ExportResult } from "./types";
-import { WgslFrameRenderer } from "./wgslFrameRenderer";
-
-const ENCODER_STALL_TIMEOUT_MS = 15_000;
-const ENCODER_FLUSH_TIMEOUT_MS = 20_000;
-
-/**
- * Waits for the encoder's queue to drain below maxEncodeQueue before returning.
- *
- * The stall timer starts fresh on each call (not from the encoder's last output), so a
- * long gap before this call — e.g. the decoder discarding frames inside a trim region —
- * doesn't get blamed on the encoder once real frames resume.
- */
-export async function waitForEncoderQueueSpace(params: {
-	getQueueSize: () => number;
-	maxEncodeQueue: number;
-	isCancelled: () => boolean;
-	encoderPreference: HardwareAcceleration;
-	now?: () => number;
-	sleep?: (ms: number) => Promise<void>;
-}): Promise<void> {
-	const now = params.now ?? Date.now;
-	const sleep = params.sleep ?? ((ms: number) => new Promise((resolve) => setTimeout(resolve, ms)));
-
-	const stallWaitStartAt = now();
-	while (params.getQueueSize() >= params.maxEncodeQueue && !params.isCancelled()) {
-		if (now() - stallWaitStartAt > ENCODER_STALL_TIMEOUT_MS) {
-			throw new Error(
-				params.encoderPreference === "prefer-hardware"
-					? "The hardware video encoder stopped responding. Retrying with a safer encoder."
-					: "The video encoder stopped responding during export.",
-			);
-		}
-		await sleep(5);
-	}
-}
-
-// D4 diagnostic: measure the ENCODER ALONE (synthetic frames, no decode/render)
-// to separate platform encoder throughput from our pipeline's feeding path.
-// Temporary — flip off/remove once the bottleneck is identified.
-const ENCODER_PROBE = false;
-
-/**
- * Route frames to the bundled native ffmpeg instead of WebCodecs.
- *
- * Read at runtime, from localStorage, ON PURPOSE: it lets one app session export
- * the same timeline both ways, so the A/B compares two runs that share a source,
- * a plan, a machine and a thermal state. A build-time constant would compare two
- * different sessions and invite us to believe the difference.
- *
- *   localStorage.setItem("openscreen.nativeEncode", "1")
- *
- * Temporary scaffold: WebCodecs goes away once the numbers are in.
- */
-function nativeEncodeEnabled(): boolean {
-	try {
-		return localStorage.getItem("openscreen.nativeEncode") === "1";
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Diagnostic: extract every frame to RAM, then throw it away. Writes no file.
- *
- * Pairs with compositeOnly, and the PAIR is the point: this arm is that one plus
- * a full copyTo(), so the difference between them is what the descent actually
- * costs. Measured: 0.03 ms/frame — nothing.
- *
- * That result bounds every "remove the crossing" proposal at once (option A'
- * sandbox:false, shared memory, a transferable Electron won't transfer) without
- * building any of them — but not for the reason this arm was built. It was built
- * to price the descent; it proved there is nothing there to price, and that the
- * 32 seconds previously blamed on readback were the compositor finishing its GPU
- * work at the first stage that forced a sync.
- *
- * See technical-documentation/architecture/export-pipeline.md
- *
- *   localStorage.setItem("openscreen.dropFrames", "1")
- */
-function dropFramesEnabled(): boolean {
-	try {
-		return localStorage.getItem("openscreen.dropFrames") === "1";
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Diagnostic: decode and composite every frame, then stop. No extract, no
- * encode, no file.
- *
- * Prices the GPU compositing of the REAL effect set — the number the whole
- * native-core case rests on. The `render` stage reads 1.7 ms/frame, but
- * renderFrame is async: it returns before the GPU is done, so that figure may be
- * charging someone else for the work. Here nothing downstream can absorb it, so
- * the wall is the compositor's own throughput.
- *
- * Combined with the measured GPU decode+encode floor (234 fps with no
- * compositing), this bounds a native GPU pipeline without building one:
- * an architecture that composites on-device cannot beat decode + THIS + encode.
- *
- *   localStorage.setItem("openscreen.compositeOnly", "1")
- */
-function compositeOnlyEnabled(): boolean {
-	try {
-		return localStorage.getItem("openscreen.compositeOnly") === "1";
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Gate G0 — technical-documentation/engineering/rendering-performance.md
- *
- * Force the GPU to FINISH compositing before the encode timers start, in a
- * `fence` stage of its own. If §7.1 is right, `encodeWait` collapses to the
- * encoder's own time and the difference reappears under `fence`; if it does
- * not, the architecture document's premise is wrong and work on it stops.
- *
- * The fence serialises compositor and encoder (no overlap), so it perturbs the
- * wall it measures: this is a measurement arm, never a shipping default.
- *
- *   localStorage.setItem("openscreen.gpuFence", "1")
- */
-function gpuFenceEnabled(): boolean {
-	try {
-		return localStorage.getItem("openscreen.gpuFence") === "1";
-	} catch {
-		return false;
-	}
-}
-
-/**
- * The §8b compositor: one WGSL program instead of Pixi + four Canvas2D surfaces
- * + a second GL context.
- *
- * POC (rendering-architecture.md Step 4). It renders no captions, annotations,
- * cursor or 3D rotation yet — so its OUTPUT is not yet the product's, and it must
- * never become a default by accident. It shares the exporter's decode, encode,
- * mux and audio, so the bench can run it against the Canvas2D compositor in one
- * interleaved pass and the difference is the compositor alone.
- *
- *   localStorage.setItem("openscreen.wgslCompositor", "1")
- */
-function wgslCompositorEnabled(): boolean {
-	try {
-		return localStorage.getItem("openscreen.wgslCompositor") === "1";
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Emit frame N of the export as a PNG on the console, for eyes.
- *
- * A compositor that runs and renders garbage produces a clean fps number, so a
- * speed arm cannot tell you whether it works. This is the cheapest path to the
- * only thing that can: the picture. It goes through the console because the
- * renderer has no file access and the alternative — encoding an mp4 — drags in a
- * 100 MB ffmpeg download to look at one frame.
- *
- *   localStorage.setItem("openscreen.dumpFrame", "60")
- */
-function dumpFrameIndex(): number | null {
-	try {
-		const raw = localStorage.getItem("openscreen.dumpFrame");
-		if (!raw) return null;
-		const n = Number(raw);
-		return Number.isFinite(n) && n >= 0 ? n : null;
-	} catch {
-		return null;
-	}
-}
-
-async function dumpFrameToConsole(canvas: HTMLCanvasElement, index: number): Promise<void> {
-	// Via a 2D surface, so this works for the WebGPU canvas and the Canvas2D one
-	// alike — drawImage is what both have in common.
-	const out = document.createElement("canvas");
-	out.width = canvas.width;
-	out.height = canvas.height;
-	const ctx = out.getContext("2d");
-	if (!ctx) return;
-	ctx.drawImage(canvas, 0, 0);
-	const png = out.toDataURL("image/png");
-	console.warn(`[bench] ${JSON.stringify({ event: "frame", index, png })}`);
-}
-
-async function probeOneEncoder(opts: {
-	label: string;
-	width: number;
-	height: number;
-	codec: string;
-	bitrate: number;
-	framerate: number;
-	hardwareAcceleration: HardwareAcceleration;
-	frameSource: "canvas" | "cpu";
-}): Promise<string> {
-	const { width, height } = opts;
-	const canvas = new OffscreenCanvas(width, height);
-	const ctx = canvas.getContext("2d");
-	if (!ctx) return `${opts.label}: no 2d ctx`;
-	let chunks = 0;
-	const encoder = new VideoEncoder({
-		output: (chunk) => {
-			chunks++;
-			void chunk;
-		},
-		error: (e) => console.warn(`[encoder probe] ${opts.label} error:`, e),
-	});
-	const config: VideoEncoderConfig = {
-		codec: opts.codec,
-		width,
-		height,
-		bitrate: opts.bitrate,
-		framerate: opts.framerate,
-		latencyMode: "quality",
-		bitrateMode: "variable",
-		hardwareAcceleration: opts.hardwareAcceleration,
-	};
-	const support = await VideoEncoder.isConfigSupported(config);
-	if (!support.supported) return `${opts.label}: unsupported`;
-	encoder.configure(config);
-	const frameCount = 120;
-	const frameDurationUs = Math.round(1_000_000 / opts.framerate);
-	const start = performance.now();
-	for (let i = 0; i < frameCount; i++) {
-		ctx.fillStyle = i % 2 ? "#1c3d5a" : "#5a1c3d";
-		ctx.fillRect(0, 0, width, height);
-		ctx.fillStyle = "#ffffff";
-		ctx.fillRect((i * 37) % width, (i * 23) % height, 80, 80);
-		let frame: VideoFrame;
-		if (opts.frameSource === "canvas") {
-			frame = new VideoFrame(canvas, { timestamp: i * frameDurationUs, duration: frameDurationUs });
-		} else {
-			const pixels = ctx.getImageData(0, 0, width, height);
-			frame = new VideoFrame(pixels.data.buffer, {
-				format: "RGBA",
-				codedWidth: width,
-				codedHeight: height,
-				timestamp: i * frameDurationUs,
-				duration: frameDurationUs,
-			});
-		}
-		while (encoder.encodeQueueSize > 8) {
-			await new Promise((resolve) => setTimeout(resolve, 2));
-		}
-		encoder.encode(frame, { keyFrame: i % 60 === 0 });
-		frame.close();
-	}
-	await encoder.flush();
-	const elapsedMs = performance.now() - start;
-	encoder.close();
-	return `${opts.label}: ${frameCount} frames in ${elapsedMs.toFixed(0)}ms = ${((frameCount / elapsedMs) * 1000).toFixed(1)} fps (${chunks} chunks)`;
-}
-
-async function runEncoderThroughputProbe(config: {
-	width: number;
-	height: number;
-	codec?: string;
-	bitrate: number;
-	frameRate: number;
-}): Promise<string> {
-	const codec = config.codec || "avc1.640033";
-	const base = {
-		width: config.width,
-		height: config.height,
-		codec,
-		bitrate: config.bitrate,
-		framerate: config.frameRate,
-	};
-	const lines: string[] = ["[encoder probe]"];
-
-	// If Chromium fell back to SwiftShader, WebGL is CPU-rasterized and the
-	// "hardware" encoder is unavailable — that alone would explain hw==sw
-	// throughput and the GPU composite showing no gain.
-	try {
-		const probeCanvas = document.createElement("canvas");
-		const gl =
-			(probeCanvas.getContext("webgl2") as WebGL2RenderingContext | null) ??
-			(probeCanvas.getContext("webgl") as WebGLRenderingContext | null);
-		if (gl) {
-			const info = gl.getExtension("WEBGL_debug_renderer_info");
-			const renderer = info
-				? gl.getParameter(info.UNMASKED_RENDERER_WEBGL)
-				: gl.getParameter(gl.RENDERER);
-			const vendor = info
-				? gl.getParameter(info.UNMASKED_VENDOR_WEBGL)
-				: gl.getParameter(gl.VENDOR);
-			lines.push(`gl: ${vendor} | ${renderer}`);
-		} else {
-			lines.push("gl: NO WEBGL CONTEXT");
-		}
-	} catch (error) {
-		lines.push(`gl: probe failed ${String(error)}`);
-	}
-	lines.push(
-		await probeOneEncoder({
-			...base,
-			label: "hw/canvas-frame",
-			hardwareAcceleration: "prefer-hardware",
-			frameSource: "canvas",
-		}),
-	);
-	lines.push(
-		await probeOneEncoder({
-			...base,
-			label: "hw/cpu-rgba-frame",
-			hardwareAcceleration: "prefer-hardware",
-			frameSource: "cpu",
-		}),
-	);
-	lines.push(
-		await probeOneEncoder({
-			...base,
-			label: "sw/canvas-frame",
-			hardwareAcceleration: "prefer-software",
-			frameSource: "canvas",
-		}),
-	);
-	lines.push(
-		await probeOneEncoder({
-			...base,
-			label: "hw/canvas-frame@720p",
-			hardwareAcceleration: "prefer-hardware",
-			frameSource: "canvas",
-			width: 1280,
-			height: 720,
-		}),
-	);
-	return lines.join("\n");
-}
-
-/** One clip's crop, in SOURCE-media time — the export renderer switches to
- * the covering entry's `cropRegion` before rendering each frame, so a crop
- * applies to its own clip only (see clipSchema.cropRegion), not the whole
- * export. */
-export interface CropScheduleEntry {
-	startSec: number;
-	endSec: number;
-	cropRegion: CropRegion;
-}
-
-export interface VideoExporterConfig extends ExportConfig {
-	videoUrl: string;
-	webcamVideoUrl?: string;
-	wallpaper: string;
-	zoomRegions: ZoomRegion[];
-	cameraFullscreenRegions?: CameraFullscreenRegion[];
-	trimRegions?: TrimRegion[];
-	speedRegions?: SpeedRegion[];
-	showShadow: boolean;
-	shadowIntensity: number;
-	showBlur: boolean;
-	motionBlurAmount?: number;
-	borderRadius?: number;
-	padding?: number;
-	videoPadding?: number;
-	/** Fallback crop when `cropSchedule` is absent or a source timestamp
-	 * doesn't fall in any entry (e.g. no clips info available). */
-	cropRegion: CropRegion;
-	/** Per-clip crop, in source-media time. When present, takes priority over
-	 * the flat `cropRegion` for every frame that falls inside one of its
-	 * entries. */
-	cropSchedule?: CropScheduleEntry[];
-	webcamLayoutPreset?: WebcamLayoutPreset;
-	webcamMaskShape?: import("@/components/video-editor/types").WebcamMaskShape;
-	webcamMirrored?: boolean;
-	webcamReactiveZoom?: boolean;
-	webcamSizePreset?: WebcamSizePreset;
-	webcamPosition?: { cx: number; cy: number } | null;
-	cursorRecordingData?: CursorRecordingData | null;
-	cursorScale?: number;
-	cursorSmoothing?: number;
-	cursorMotionBlur?: number;
-	cursorClickBounce?: number;
-	cursorClipToBounds?: boolean;
-	cursorTheme?: string;
-	annotationRegions?: AnnotationRegion[];
-	previewWidth?: number;
-	previewHeight?: number;
-	cursorTelemetry?: import("@/components/video-editor/types").CursorTelemetryPoint[];
-	cursorClickTimestamps?: number[];
-	onProgress?: (progress: ExportProgress) => void;
-	// v2 multi-asset render plan (ordered segments, virtual-time effects,
-	// per-segment cursor). Present when built by documentExporter; the segment
-	// loop consumes it. Absent for the legacy single-asset callers.
-	renderPlan?: RenderPlan;
-}
-
-const SOURCE_COPY_EPSILON = 0.0001;
-// Looser than SOURCE_COPY_EPSILON: container-reported avg frame rate is a
-// rounded rational (e.g. 59.94 for a "60fps" recording), so this only needs
-// to catch a genuinely different rate selection (24/30/60), not that noise.
-const FRAME_RATE_EPSILON = 0.5;
-
-function hasActiveTimeRegions(regions?: Array<{ startMs: number; endMs: number }>) {
-	return Boolean(regions?.some((region) => region.endMs - region.startMs > SOURCE_COPY_EPSILON));
-}
-
-function hasActiveSpeedRegions(regions?: SpeedRegion[]) {
-	return Boolean(
-		regions?.some(
-			(region) =>
-				region.endMs - region.startMs > SOURCE_COPY_EPSILON &&
-				Math.abs(region.speed - 1) > SOURCE_COPY_EPSILON,
-		),
-	);
-}
-
-function hasNativeCursorOverlay(config: VideoExporterConfig) {
-	return (config.cursorScale ?? 0) > 0;
-}
-
-function isDefaultCrop(cropRegion: CropRegion) {
-	return (
-		Math.abs(cropRegion.x) <= SOURCE_COPY_EPSILON &&
-		Math.abs(cropRegion.y) <= SOURCE_COPY_EPSILON &&
-		Math.abs(cropRegion.width - 1) <= SOURCE_COPY_EPSILON &&
-		Math.abs(cropRegion.height - 1) <= SOURCE_COPY_EPSILON
-	);
-}
-
-function hasNonDefaultCrop(config: VideoExporterConfig): boolean {
-	if (config.cropSchedule && config.cropSchedule.length > 0) {
-		return config.cropSchedule.some((entry) => !isDefaultCrop(entry.cropRegion));
-	}
-	return !isDefaultCrop(config.cropRegion);
-}
-
-/** Finds which clip's crop applies at a given SOURCE-media timestamp — the
- * first schedule entry whose [startSec, endSec) covers it, falling back to
- * `fallback` when the schedule is absent or nothing covers it (e.g. a gap). */
-export function resolveCropAt(
-	schedule: CropScheduleEntry[] | undefined,
-	sourceSec: number,
-	fallback: CropRegion,
-): CropRegion {
-	if (!schedule || schedule.length === 0) return fallback;
-	const covering = schedule.find(
-		(entry) => sourceSec >= entry.startSec && sourceSec < entry.endSec,
-	);
-	return covering?.cropRegion ?? fallback;
-}
-
-interface SourceCopyVideoInfo {
-	width: number;
-	height: number;
-	frameRate: number;
-	codec: string;
-}
-
-export function isSourceCopyFastPathEligible(
-	config: VideoExporterConfig,
-	videoInfo: SourceCopyVideoInfo,
-) {
-	return getSourceCopyFastPathBlockers(config, videoInfo).length === 0;
-}
-
-export function getSourceCopyFastPathBlockers(
-	config: VideoExporterConfig,
-	videoInfo: SourceCopyVideoInfo,
-) {
-	const blockers: string[] = [];
-
-	if (config.width !== videoInfo.width || config.height !== videoInfo.height) {
-		blockers.push(
-			`output-size ${config.width}x${config.height} differs from source ${videoInfo.width}x${videoInfo.height}`,
-		);
-	}
-	// A copied file keeps the source's exact frame rate/codec — if the user
-	// picked a different one in the export dialog, honor it by re-encoding
-	// instead of silently shipping the source's encoding under a different
-	// label.
-	if (Math.abs(config.frameRate - videoInfo.frameRate) > FRAME_RATE_EPSILON) {
-		blockers.push(`frame rate ${config.frameRate} differs from source ${videoInfo.frameRate}`);
-	}
-	if (config.codec && videoCodecFamily(config.codec) !== videoCodecFamily(videoInfo.codec)) {
-		blockers.push(`codec ${config.codec} differs from source ${videoInfo.codec}`);
-	}
-	if (config.webcamVideoUrl) blockers.push("webcam overlay is enabled");
-	if (hasActiveTimeRegions(config.trimRegions)) blockers.push("trim regions are present");
-	if (hasActiveSpeedRegions(config.speedRegions)) blockers.push("speed regions are present");
-	if (hasActiveTimeRegions(config.zoomRegions)) blockers.push("zoom regions are present");
-	if (hasActiveTimeRegions(config.cameraFullscreenRegions))
-		blockers.push("camera fullscreen regions are present");
-	if (hasActiveTimeRegions(config.annotationRegions))
-		blockers.push("annotation regions are present");
-	if (hasNativeCursorOverlay(config)) blockers.push("editable cursor overlay is enabled");
-	if (hasNonDefaultCrop(config)) blockers.push("crop is not default");
-	if ((config.padding ?? 0) > SOURCE_COPY_EPSILON) blockers.push("padding is not zero");
-	if ((config.videoPadding ?? 0) > SOURCE_COPY_EPSILON) blockers.push("video padding is not zero");
-	if ((config.borderRadius ?? 0) > SOURCE_COPY_EPSILON) blockers.push("roundness is not zero");
-	if (config.showShadow || config.shadowIntensity > SOURCE_COPY_EPSILON) {
-		blockers.push("shadow is enabled");
-	}
-	if (config.showBlur) blockers.push("background blur is enabled");
-	if ((config.motionBlurAmount ?? 0) > SOURCE_COPY_EPSILON) blockers.push("motion blur is enabled");
-
-	return blockers;
-}
-
-/** Projects timeline-authored regions (zoom/annotation/speed, in virtual/timeline
- * ms) onto ONE segment's SOURCE time. Timeline↔source is 1:1 within a clip, so
- * the covered part of each region maps by its offset from the clip's timeline
- * start; regions not covering the segment are dropped. Speed is applied on top
- * by the decoder over the projected source span, and the frame loop matches
- * zoom/annotation/cursor by the frame's SOURCE time — so everything stays
- * aligned even when speed makes output time diverge from timeline time. */
-function projectRegionsToSegmentSource<T extends { startMs: number; endMs: number }>(
-	regions: T[],
-	segment: RenderSegment,
-): T[] {
-	const out: T[] = [];
-	const tStart = segment.timelineStartSec;
-	const tEnd = segment.timelineEndSec;
-	for (const region of regions) {
-		const lo = Math.min(region.startMs, region.endMs) / 1000;
-		const hi = Math.max(region.startMs, region.endMs) / 1000;
-		const s = Math.max(lo, tStart);
-		const e = Math.min(hi, tEnd);
-		if (e <= s) continue; // region does not cover this segment
-		const srcStart = segment.sourceStartSec + (s - tStart);
-		const srcEnd = segment.sourceStartSec + (e - tStart);
-		out.push({
-			...region,
-			startMs: Math.round(srcStart * 1000),
-			endMs: Math.round(srcEnd * 1000),
-		});
-	}
-	return out;
-}
-
-/** Source-time spans to CUT for one segment so its decoder emits exactly
- * [sourceStart, sourceEnd) minus the clip's intra-trims: the complement of the
- * kept window over [0, sourceDuration] plus the intra-trims (v2 segment loop). */
-function buildSegmentRenderTrims(segment: RenderSegment, sourceDurationSec: number): TrimRegion[] {
-	const cuts: Array<{ startSec: number; endSec: number }> = [];
-	if (segment.sourceStartSec > 0) {
-		cuts.push({ startSec: 0, endSec: segment.sourceStartSec });
-	}
-	const keptEnd = Math.min(segment.sourceEndSec, sourceDurationSec);
-	if (keptEnd < sourceDurationSec) {
-		cuts.push({ startSec: keptEnd, endSec: sourceDurationSec });
-	}
-	for (const trim of segment.intraTrims) {
-		cuts.push({ startSec: trim.startSec, endSec: trim.endSec });
-	}
-	return cuts.map((cut, i) => ({
-		id: `seg_trim_${i + 1}`,
-		startMs: Math.round(cut.startSec * 1000),
-		endMs: Math.round(cut.endSec * 1000),
-	}));
-}
-
-/** Per-segment cursor recording for the renderer: the plan's shared cursor
- * atlas/style + THIS segment's asset samples (empty → no overlay). */
-function segmentCursorRecording(
-	plan: RenderPlan,
-	segment: RenderSegment,
-): CursorRecordingData | null {
-	if (!plan.cursor) return null;
-	return {
-		version: plan.cursor.version,
-		provider: plan.cursor.provider,
-		assets: plan.cursor.assets,
-		samples: segment.cursorSamples,
-	};
-}
-
-// v2 multi-asset audio output layout. Both recording formats are 48 kHz, so
-// decodeAudioData is an identity resample; only channel counts get normalized.
-const AUDIO_OUTPUT_SAMPLE_RATE = 48_000;
-const AUDIO_OUTPUT_CHANNELS = 2;
-// Short equal-power fade applied at each segment audio join (seamless audio).
-const AUDIO_BOUNDARY_FADE_SEC = 0.005;
-
-/** Source-time sub-intervals of a segment that are KEPT — its window minus
- * intra-trims (the complement of buildSegmentRenderTrims within the clip) — so
- * the segment's audio removes exactly the same cuts as its video. */
-function keptSourceIntervals(segment: RenderSegment): Array<{ startSec: number; endSec: number }> {
-	const kept: Array<{ startSec: number; endSec: number }> = [];
-	let cursor = segment.sourceStartSec;
-	const trims = [...segment.intraTrims].sort((a, b) => a.startSec - b.startSec);
-	for (const trim of trims) {
-		const trimStart = Math.max(trim.startSec, segment.sourceStartSec);
-		const trimEnd = Math.min(trim.endSec, segment.sourceEndSec);
-		if (trimEnd <= cursor) continue;
-		if (trimStart > cursor) {
-			kept.push({ startSec: cursor, endSec: Math.min(trimStart, segment.sourceEndSec) });
-		}
-		cursor = Math.max(cursor, trimEnd);
-	}
-	if (cursor < segment.sourceEndSec) {
-		kept.push({ startSec: cursor, endSec: segment.sourceEndSec });
-	}
-	return kept;
-}
-
-/** Decodes ONE segment's audio to planar PCM at the common export layout
- * (sampleRate/channels), keeping only the clip's source window minus its
- * intra-trims. Channel counts are normalized via the shared downmix. Returns
- * null when the source has no decodable audio track. */
-async function decodeSegmentAudioPcm(
-	segment: RenderSegment,
-	sampleRate: number,
-	channels: number,
-): Promise<Float32Array[] | null> {
-	let file: File | null = null;
-	try {
-		file = await materializeLocalSourceFile(segment.videoUrl, `seg-${segment.clipId}-audio`);
-		const bytes = await file.arrayBuffer();
-		const ctx = new OfflineAudioContext(Math.max(1, channels), 1, sampleRate);
-		let audioBuffer: AudioBuffer;
-		try {
-			audioBuffer = await ctx.decodeAudioData(bytes);
-		} catch {
-			return null; // no decodable audio track
-		}
-		const sourceChannels = audioBuffer.numberOfChannels;
-		if (sourceChannels === 0) return null;
-
-		const sourcePlanes: Float32Array[] = [];
-		for (let c = 0; c < sourceChannels; c++) sourcePlanes.push(audioBuffer.getChannelData(c));
-
-		// Concatenate the kept source sub-intervals (intra-trims removed), per channel.
-		const kept = keptSourceIntervals(segment);
-		const keptChannels: Float32Array[] = [];
-		for (let c = 0; c < sourceChannels; c++) {
-			const total = kept.reduce((acc, iv) => {
-				const s0 = Math.max(0, Math.round(iv.startSec * sampleRate));
-				const s1 = Math.min(sourcePlanes[c].length, Math.round(iv.endSec * sampleRate));
-				return acc + Math.max(0, s1 - s0);
-			}, 0);
-			const out = new Float32Array(total);
-			let w = 0;
-			for (const iv of kept) {
-				const s0 = Math.max(0, Math.round(iv.startSec * sampleRate));
-				const s1 = Math.min(sourcePlanes[c].length, Math.round(iv.endSec * sampleRate));
-				if (s1 > s0) {
-					out.set(sourcePlanes[c].subarray(s0, s1), w);
-					w += s1 - s0;
-				}
-			}
-			keptChannels.push(out);
-		}
-
-		if (sourceChannels === channels) return keptChannels;
-
-		// Normalize channel count (e.g. mono → stereo) with the shared downmix,
-		// which returns one planar Float32Array (ch0 samples, then ch1, …).
-		const frameCount = keptChannels[0]?.length ?? 0;
-		if (frameCount === 0) return [];
-		const downmixed = downmixPlanarChannelsForExport(keptChannels, channels);
-		const result: Float32Array[] = [];
-		for (let c = 0; c < channels; c++) {
-			result.push(downmixed.subarray(c * frameCount, (c + 1) * frameCount));
-		}
-		return result;
-	} catch (error) {
-		console.warn("[VideoExporter] segment audio decode failed:", error);
-		return null;
-	} finally {
-		if (file) releaseLocalSourceFile(file.name);
-	}
-}
-
-/** Pitch-preserving (WSOLA) time-stretch of a segment's planar PCM to exactly
- * `targetSamples` per channel, so audio matches the segment's speed-retimed
- * video length and A/V stays locked. Pass-through when already the right length
- * (constant 1× segment). A single stretch factor is applied across the segment
- * (uniform over any speed variation within it — total length is exact, which is
- * what keeps the joins synced; per-region audio retiming is a refinement). */
-function timeStretchPcmToLength(
-	pcm: Float32Array[],
-	sampleRate: number,
-	channels: number,
-	targetSamples: number,
-): Float32Array[] {
-	if (targetSamples <= 0) return Array.from({ length: channels }, () => new Float32Array(0));
-	const sourceSamples = pcm[0]?.length ?? 0;
-	if (sourceSamples === 0 || Math.abs(sourceSamples - targetSamples) <= 1) return pcm;
-
-	const speed = sourceSamples / targetSamples; // >1 = speed up (compress)
-	const stretcher = new WsolaTimeStretcher({
-		sampleRate,
-		channels,
-		speed,
-		expectedOutputSamples: targetSamples,
-	});
-	const chunks = [stretcher.push(pcm), stretcher.flush()];
-	const result: Float32Array[] = [];
-	for (let c = 0; c < channels; c++) {
-		const out = new Float32Array(targetSamples);
-		let w = 0;
-		for (const chunk of chunks) {
-			const src = chunk[c];
-			if (!src) continue;
-			const n = Math.min(src.length, targetSamples - w);
-			if (n > 0) {
-				out.set(src.subarray(0, n), w);
-				w += n;
-			}
-		}
-		result.push(out);
-	}
-	return result;
-}
-
-/** Concatenate planar PCM chunks (one array-of-channels per chunk) per channel. */
-function concatPlanarChunks(chunks: Float32Array[][], channels: number): Float32Array[] {
-	const result: Float32Array[] = [];
-	for (let c = 0; c < channels; c++) {
-		let total = 0;
-		for (const chunk of chunks) total += chunk[c]?.length ?? 0;
-		const out = new Float32Array(total);
-		let w = 0;
-		for (const chunk of chunks) {
-			const src = chunk[c];
-			if (!src) continue;
-			out.set(src, w);
-			w += src.length;
-		}
-		result.push(out);
-	}
-	return result;
-}
-
-/** Time-stretch a segment's kept audio PER speed sub-segment (not uniformly), so
- * a partial speed region inside a clip retimes only its own span — matching how
- * the video decoder applies speed. The sub-segments and their output frame counts
- * are computed EXACTLY as the decoder does (splitBySpeed of the kept intervals,
- * then ceil((dur-ε)/speed·fps) frames each), so audio stays frame-locked to the
- * video. The kept PCM (decodeSegmentAudioPcm) is the concatenation of those same
- * kept intervals, so a running cursor slices it in order. */
-function stretchSegmentAudioBySpeed(
-	pcm: Float32Array[],
-	segment: RenderSegment,
-	speedRegions: SpeedRegion[],
-	sampleRate: number,
-	channels: number,
-	frameRate: number,
-): Float32Array[] {
-	const segmentTrims = buildSegmentRenderTrims(segment, segment.sourceEndSec);
-	const speedSegs = splitBySpeed(
-		computeKeepSegments(segment.sourceEndSec, segmentTrims),
-		speedRegions,
-	);
-	if (speedSegs.length === 0) return pcm;
-
-	const VIDEO_EPSILON_SEC = 0.001; // must match streamingDecoder's per-segment quantization
-	const totalKept = pcm[0]?.length ?? 0;
-	const chunks: Float32Array[][] = [];
-	let keptCursor = 0;
-	for (const seg of speedSegs) {
-		const inSamples = Math.round((seg.endSec - seg.startSec) * sampleRate);
-		const inStart = keptCursor;
-		const inEnd = Math.min(inStart + inSamples, totalKept);
-		keptCursor = inStart + inSamples;
-
-		const frameCount = Math.ceil(
-			((seg.endSec - seg.startSec - VIDEO_EPSILON_SEC) / seg.speed) * frameRate,
-		);
-		const outSamples = Math.max(0, Math.round((frameCount / frameRate) * sampleRate));
-
-		if (inEnd <= inStart) {
-			// No source audio for this span (past the buffer) → silence of its length.
-			chunks.push(Array.from({ length: channels }, () => new Float32Array(outSamples)));
-			continue;
-		}
-		const slice = pcm.map((ch) => ch.subarray(inStart, inEnd));
-		chunks.push(timeStretchPcmToLength(slice, sampleRate, channels, outSamples));
-	}
-	return concatPlanarChunks(chunks, channels);
-}
-
-function isMp4Source(videoUrl: string, blob: Blob) {
-	if (blob.type.toLowerCase().includes("mp4")) {
-		return true;
-	}
-
-	try {
-		const path = new URL(videoUrl, window.location.href).pathname;
-		return path.toLowerCase().endsWith(".mp4");
-	} catch {
-		return videoUrl.toLowerCase().split(/[?#]/, 1)[0].endsWith(".mp4");
-	}
-}
-
-export class VideoExporter {
-	private config: VideoExporterConfig;
-	private streamingDecoder: StreamingVideoDecoder | null = null;
-	private renderer: FrameRenderer | null = null;
-	private encoder: VideoEncoder | null = null;
-	private muxer: VideoMuxer | null = null;
-	private nativeSink: NativeFrameSink | null = null;
-	private audioProcessor: AudioProcessor | null = null;
-	private webcamDecoder: StreamingVideoDecoder | null = null;
-	private cancelled = false;
-	private encodeQueue = 0;
-	// Keep a smaller queue for software encoding so Windows does not balloon memory.
-	private readonly MAX_ENCODE_QUEUE = 120;
-	private videoDescription: Uint8Array | undefined;
-	private videoColorSpace: VideoColorSpaceInit | undefined;
-	private muxingPromises: Promise<void>[] = [];
-	private chunkCount = 0;
-	private fatalEncoderError: Error | null = null;
-
-	constructor(config: VideoExporterConfig) {
-		this.config = config;
-	}
-
-	async export(): Promise<ExportResult> {
-		const encoderPreferences = this.getEncoderPreferences();
-		let lastError: Error | null = null;
-
-		for (const encoderPreference of encoderPreferences) {
-			try {
-				return await this.exportWithEncoderPreference(encoderPreference);
-			} catch (error) {
-				const normalizedError = error instanceof Error ? error : new Error(String(error));
-				lastError = normalizedError;
-
-				if (this.cancelled) {
-					return { success: false, error: "Export cancelled" };
-				}
-
-				if (normalizedError instanceof BackgroundLoadError) {
-					throw normalizedError;
-				}
-
-				if (encoderPreferences.length > 1) {
-					console.warn(
-						`[VideoExporter] ${encoderPreference} export attempt failed:`,
-						normalizedError,
-					);
-				}
-			} finally {
-				this.cleanup();
-			}
-		}
-
-		return {
-			success: false,
-			error: lastError?.message || "Export failed",
-		};
-	}
-
-	private async exportWithEncoderPreference(
-		encoderPreference: HardwareAcceleration,
-	): Promise<ExportResult> {
-		let webcamFrameQueue: TimestampedVideoFrameQueue | null = null;
-		let stopWebcamDecode = false;
-		let webcamDecodeError: Error | null = null;
-		let webcamDecodePromise: Promise<void> | null = null;
-		let webcamDecoder: StreamingVideoDecoder | null = null;
-		const warnings: string[] = [];
-		const onWarning = (message: string) => warnings.push(message);
-
-		this.cleanup();
-		this.cancelled = false;
-		this.fatalEncoderError = null;
-
-		try {
-			// v2 path: ALL AI-edition exports (single- or multi-clip) render through
-			// the segment loop — one unified path, no mono-asset special-casing. The
-			// single-stream pipeline below survives only for legacy callers that pass
-			// no renderPlan (the out-of-scope components/video-editor exporter).
-			const segmentPlan = this.config.renderPlan;
-			if (segmentPlan && segmentPlan.segments.length > 0) {
-				return await this.runSegmentLoop(encoderPreference, segmentPlan);
-			}
-
-			const platform = await getPlatform();
-
-			const streamingDecoder = new StreamingVideoDecoder();
-			this.streamingDecoder = streamingDecoder;
-			const videoInfo = await streamingDecoder.loadMetadata(
-				this.config.videoUrl,
-				({ copiedBytes, totalBytes }) => {
-					// Large recordings are streamed into OPFS before demuxing; surface
-					// that copy as a "preparing" phase so the dialog is not stuck at 0%.
-					this.reportProgress({
-						currentFrame: 0,
-						totalFrames: 0,
-						percentage: totalBytes > 0 ? (copiedBytes / totalBytes) * 100 : 0,
-						estimatedTimeRemaining: 0,
-						phase: "preparing",
-					});
-				},
-			);
-			const sourceCopyResult = await this.trySourceCopyFastPath(videoInfo);
-			if (sourceCopyResult) {
-				return sourceCopyResult;
-			}
-
-			let webcamInfo: Awaited<ReturnType<StreamingVideoDecoder["loadMetadata"]>> | null = null;
-			if (this.config.webcamVideoUrl) {
-				webcamDecoder = new StreamingVideoDecoder();
-				this.webcamDecoder = webcamDecoder;
-				webcamInfo = await webcamDecoder.loadMetadata(this.config.webcamVideoUrl);
-			}
-
-			const renderer = new FrameRenderer({
-				width: this.config.width,
-				height: this.config.height,
-				wallpaper: this.config.wallpaper,
-				zoomRegions: this.config.zoomRegions,
-				cameraFullscreenRegions: this.config.cameraFullscreenRegions,
-				showShadow: this.config.showShadow,
-				shadowIntensity: this.config.shadowIntensity,
-				showBlur: this.config.showBlur,
-				motionBlurAmount: this.config.motionBlurAmount,
-				borderRadius: this.config.borderRadius,
-				padding: this.config.padding,
-				cropRegion: this.config.cropRegion,
-				cursorRecordingData: this.config.cursorRecordingData,
-				cursorScale: this.config.cursorScale,
-				cursorSmoothing: this.config.cursorSmoothing,
-				cursorMotionBlur: this.config.cursorMotionBlur,
-				cursorClickBounce: this.config.cursorClickBounce,
-				cursorClipToBounds: this.config.cursorClipToBounds,
-				cursorTheme: this.config.cursorTheme,
-				videoWidth: videoInfo.width,
-				videoHeight: videoInfo.height,
-				webcamSize: webcamInfo ? { width: webcamInfo.width, height: webcamInfo.height } : null,
-				webcamLayoutPreset: this.config.webcamLayoutPreset,
-				webcamMaskShape: this.config.webcamMaskShape,
-				webcamMirrored: this.config.webcamMirrored,
-				webcamReactiveZoom: this.config.webcamReactiveZoom,
-				webcamSizePreset: this.config.webcamSizePreset,
-				webcamPosition: this.config.webcamPosition,
-				annotationRegions: this.config.annotationRegions,
-				speedRegions: this.config.speedRegions,
-				previewWidth: this.config.previewWidth,
-				previewHeight: this.config.previewHeight,
-				cursorTelemetry: this.config.cursorTelemetry,
-				cursorClickTimestamps: this.config.cursorClickTimestamps,
-				platform,
-			});
-			this.renderer = renderer;
-			await renderer.initialize();
-
-			await this.initializeEncoder(encoderPreference);
-
-			const sourceDemuxer = streamingDecoder.getDemuxer();
-			const audioExportCodec =
-				videoInfo.hasAudio && sourceDemuxer
-					? await AudioProcessor.selectSupportedExportCodecForSource(sourceDemuxer)
-					: null;
-			if (videoInfo.hasAudio && !audioExportCodec) {
-				console.warn("[VideoExporter] No supported audio export codec, exporting video-only.");
-			}
-
-			const hasAudio = Boolean(audioExportCodec);
-			const muxer = new VideoMuxer(this.config, hasAudio, audioExportCodec?.muxerCodec);
-			this.muxer = muxer;
-			await muxer.initialize();
-
-			const { totalFrames } = streamingDecoder.getExportMetrics(
-				this.config.frameRate,
-				this.config.trimRegions,
-				this.config.speedRegions,
-			);
-
-			const frameDuration = 1_000_000 / this.config.frameRate;
-			let frameIndex = 0;
-			const maxEncodeQueue =
-				encoderPreference === "prefer-software"
-					? Math.min(this.MAX_ENCODE_QUEUE, 32)
-					: this.MAX_ENCODE_QUEUE;
-
-			webcamFrameQueue = this.config.webcamVideoUrl ? new TimestampedVideoFrameQueue() : null;
-			webcamDecodePromise =
-				webcamDecoder && webcamFrameQueue
-					? (() => {
-							const queue = webcamFrameQueue;
-							return webcamDecoder
-								.decodeAll(
-									this.config.frameRate,
-									this.config.trimRegions,
-									this.config.speedRegions,
-									async (webcamFrame, _exportTimestampUs, webcamSourceTimestampMs) => {
-										while (queue.length >= 12 && !this.cancelled && !stopWebcamDecode) {
-											await new Promise((resolve) => setTimeout(resolve, 2));
-										}
-										if (this.cancelled || stopWebcamDecode) {
-											webcamFrame.close();
-											return;
-										}
-										queue.enqueue(webcamFrame, webcamSourceTimestampMs);
-									},
-									onWarning,
-								)
-								.catch((error) => {
-									webcamDecodeError = error instanceof Error ? error : new Error(String(error));
-									throw webcamDecodeError;
-								})
-								.finally(() => {
-									if (webcamDecodeError) {
-										queue.fail(webcamDecodeError);
-									} else {
-										queue.close();
-									}
-								});
-						})()
-					: null;
-
-			await streamingDecoder.decodeAll(
-				this.config.frameRate,
-				this.config.trimRegions,
-				this.config.speedRegions,
-				async (videoFrame, _exportTimestampUs, sourceTimestampMs) => {
-					let webcamFrame: VideoFrame | null = null;
-					try {
-						if (this.cancelled) {
-							return;
-						}
-
-						if (this.fatalEncoderError) {
-							throw this.fatalEncoderError;
-						}
-
-						const timestamp = frameIndex * frameDuration;
-						webcamFrame = webcamFrameQueue
-							? await webcamFrameQueue.frameAt(sourceTimestampMs)
-							: null;
-						if (this.cancelled) {
-							return;
-						}
-
-						const sourceTimestampUs = sourceTimestampMs * 1000;
-						// Crop is per-clip — switch to whichever clip's crop covers this
-						// frame's source time before rendering it (see
-						// FrameRenderer.setCropRegion / resolveCropAt).
-						renderer.setCropRegion(
-							resolveCropAt(
-								this.config.cropSchedule,
-								sourceTimestampMs / 1000,
-								this.config.cropRegion,
-							),
-						);
-						await renderer.renderFrame(videoFrame, sourceTimestampUs, webcamFrame);
-
-						const canvas = renderer.getCanvas();
-
-						let exportFrame: VideoFrame;
-
-						// On some Linux systems the GPU shared-image path (EGL/Ozone) fails
-						// silently, producing empty frames, so we force a CPU readback instead.
-						if (platform === "linux") {
-							const canvasCtx = canvas.getContext("2d")!;
-							const imageData = canvasCtx.getImageData(0, 0, canvas.width, canvas.height);
-							exportFrame = new VideoFrame(imageData.data.buffer, {
-								format: "RGBA",
-								codedWidth: canvas.width,
-								codedHeight: canvas.height,
-								timestamp,
-								duration: frameDuration,
-								colorSpace: {
-									primaries: "bt709",
-									transfer: "iec61966-2-1",
-									matrix: "rgb",
-									fullRange: true,
-								},
-							});
-						} else {
-							exportFrame = new VideoFrame(canvas, { timestamp, duration: frameDuration });
-						}
-
-						try {
-							await waitForEncoderQueueSpace({
-								getQueueSize: () => this.encoder?.encodeQueueSize ?? 0,
-								maxEncodeQueue,
-								isCancelled: () => this.cancelled,
-								encoderPreference,
-							});
-						} catch (error) {
-							exportFrame.close();
-							throw error;
-						}
-
-						if (this.encoder && this.encoder.state === "configured") {
-							this.encodeQueue++;
-							this.encoder.encode(exportFrame, { keyFrame: frameIndex % 150 === 0 });
-						} else {
-							console.warn(
-								`[Frame ${frameIndex}] Encoder not ready! State: ${this.encoder?.state}`,
-							);
-						}
-
-						exportFrame.close();
-						frameIndex++;
-
-						this.reportProgress({
-							currentFrame: frameIndex,
-							totalFrames,
-							percentage: (frameIndex / totalFrames) * 100,
-							estimatedTimeRemaining: 0,
-						});
-					} finally {
-						videoFrame.close();
-						webcamFrame?.close();
-					}
-				},
-				onWarning,
-			);
-
-			if (this.cancelled) {
-				return { success: false, error: "Export cancelled" };
-			}
-
-			if (this.fatalEncoderError) {
-				throw this.fatalEncoderError;
-			}
-
-			stopWebcamDecode = true;
-			webcamFrameQueue?.destroy();
-			webcamDecoder?.cancel();
-			await webcamDecodePromise;
-
-			if (this.encoder && this.encoder.state === "configured") {
-				await this.withTimeout(
-					this.encoder.flush(),
-					ENCODER_FLUSH_TIMEOUT_MS,
-					encoderPreference === "prefer-hardware"
-						? "The hardware video encoder stopped responding while finalizing the export."
-						: "The video encoder stopped responding while finalizing the export.",
-				);
-			}
-
-			if (this.fatalEncoderError) {
-				throw this.fatalEncoderError;
-			}
-
-			await Promise.all(this.muxingPromises);
-
-			this.reportProgress({
-				currentFrame: totalFrames,
-				totalFrames,
-				percentage: 100,
-				estimatedTimeRemaining: 0,
-				phase: "finalizing",
-			});
-
-			if (hasAudio && audioExportCodec && !this.cancelled) {
-				const demuxer = streamingDecoder.getDemuxer();
-				if (demuxer) {
-					console.log("[VideoExporter] Processing audio track...");
-					this.audioProcessor = new AudioProcessor();
-					await this.audioProcessor.process(
-						demuxer,
-						muxer,
-						this.config.videoUrl,
-						this.config.trimRegions,
-						this.config.speedRegions,
-						videoInfo.duration,
-						audioExportCodec,
-						this.config.frameRate,
-					);
-				}
-			}
-
-			const blob = await muxer.finalize();
-			return { success: true, blob, warnings: warnings.length > 0 ? warnings : undefined };
-		} finally {
-			stopWebcamDecode = true;
-			webcamFrameQueue?.destroy();
-			webcamDecoder?.cancel();
-			if (webcamDecodePromise) {
-				await webcamDecodePromise.catch(() => undefined);
-			}
-		}
-	}
-
-	/**
-	 * v2 multi-asset segment loop. Walks the RenderPlan's ordered segments,
-	 * decoding each from its OWN source asset into ONE renderer + encoder + muxer,
-	 * advancing a single continuous virtual-time frame clock across segment
-	 * boundaries so the joins are seamless. Fixes P1 (non-primary clips dropped).
-	 *
-	 * Renders per-segment video + webcam overlay + cursor, each drawn from its
-	 * OWN asset (webcam source + cursor samples switch at every segment boundary).
-	 * Per-segment audio concat (see audioConcatPlan) and virtual-time speed
-	 * mapping are the remaining increments. The caller has already run
-	 * cleanup()/reset.
-	 */
-	private async runSegmentLoop(
-		encoderPreference: HardwareAcceleration,
-		plan: RenderPlan,
-	): Promise<ExportResult> {
-		const warnings: string[] = [];
-		const onWarning = (message: string) => warnings.push(message);
-		const platform = await getPlatform();
-		const segments = plan.segments;
-		const firstSegment = segments[0];
-
-		// Phase-0 perf harness: accumulate per-stage time to find the bottleneck.
-		const timings = new StageTimings();
-		const wallStart = performance.now();
-
-		if (ENCODER_PROBE) {
-			try {
-				console.warn(await runEncoderThroughputProbe(this.config));
-			} catch (error) {
-				console.warn("[encoder probe] failed:", error);
-			}
-		}
-
-		// One renderer for the whole export — output size is fixed; only the
-		// source-dependent fields change per segment via renderer.setSource().
-		const useWgsl = wgslCompositorEnabled();
-		if (useWgsl) {
-			console.warn("[export perf] WGSL compositor: POC — no captions, annotations, cursor or 3D");
-		}
-		const RendererClass = useWgsl
-			? (WgslFrameRenderer as unknown as typeof FrameRenderer)
-			: FrameRenderer;
-		const renderer = new RendererClass({
-			width: this.config.width,
-			height: this.config.height,
-			wallpaper: plan.appearance.wallpaper,
-			zoomRegions: plan.zoomRegions,
-			annotationRegions: plan.annotationRegions,
-			speedRegions: plan.speedRegions,
-			showShadow: plan.appearance.shadowIntensity > 0,
-			shadowIntensity: plan.appearance.shadowIntensity,
-			showBlur: plan.appearance.showBlur,
-			motionBlurAmount: plan.appearance.motionBlurAmount,
-			borderRadius: plan.appearance.borderRadius,
-			padding: plan.appearance.padding,
-			cropRegion: firstSegment.cropRegion,
-			videoWidth: firstSegment.sourceWidth,
-			videoHeight: firstSegment.sourceHeight,
-			// Source-dependent fields (webcamSize, cursor samples/scale) are set per
-			// segment via setSource; webcam layout + cursor style are global.
-			webcamSize: null,
-			webcamLayoutPreset: plan.webcam.layoutPreset,
-			webcamMaskShape: plan.webcam.maskShape,
-			webcamMirrored: plan.webcam.mirrored,
-			webcamReactiveZoom: plan.webcam.reactiveZoom,
-			webcamSizePreset: plan.webcam.sizePreset,
-			webcamPosition: plan.webcam.position,
-			cursorScale: plan.cursor?.scale ?? 0,
-			cursorSmoothing: plan.cursor?.smoothing,
-			cursorMotionBlur: plan.cursor?.motionBlur,
-			cursorClickBounce: plan.cursor?.clickBounce,
-			cursorClipToBounds: plan.cursor?.clipToBounds,
-			cursorTheme: plan.cursor?.theme,
-			platform,
-		});
-		this.renderer = renderer;
-		await renderer.initialize();
-
-		// --- Frame sink: native ffmpeg, or the WebCodecs path it is replacing ---
-		const api = window.electronAPI as unknown as NativeSinkApi | undefined;
-		const useNative = nativeEncodeEnabled() && typeof api?.exportStart === "function";
-		// Ceiling diagnostics: extract but never ship, or do not even extract.
-		// Both produce NO FILE — they price one stage in isolation.
-		const compositeOnly = useNative && compositeOnlyEnabled();
-		const dropFrames = useNative && !compositeOnly && dropFramesEnabled();
-		// Gate G0: sync the GPU after compositing, before anything downstream runs.
-		const gpuFence = gpuFenceEnabled();
-		if (gpuFence) {
-			console.warn("[export perf] G0 fence: GPU synced after compositing, per frame");
-		}
-		const dumpAt = dumpFrameIndex();
-		let sink: NativeFrameSink | null = null;
-		let extractor: CanvasFrameExtractor | null = null;
-		if (useNative && api && compositeOnly) {
-			console.warn("[export perf] composite ceiling: render only, NO EXTRACT, NO FILE WRITTEN");
-		} else if (useNative && api) {
-			extractor = new CanvasFrameExtractor(this.config.width, this.config.height);
-			if (dropFrames) {
-				console.warn("[export perf] readback ceiling: extract and discard, NO FILE WRITTEN");
-			} else {
-				sink = await NativeFrameSink.start(
-					{
-						width: this.config.width,
-						height: this.config.height,
-						frameRate: this.config.frameRate,
-						// Same field the WebCodecs encoder is configured from, so the A/B
-						// compares two runs at one bitrate.
-						bitrate: this.config.bitrate,
-						// BGRA is all Chromium will copy out of a canvas; NV12 packing is
-						// the next step (see frameExtract.ts).
-						pixelFormat: extractor.pixelFormat,
-					},
-					api,
-				);
-				this.nativeSink = sink;
-				console.warn(`[export perf] native encode via ${sink.encoder} -> ${sink.outputPath}`);
-			}
-		} else {
-			await this.initializeEncoder(encoderPreference);
-		}
-
-		// Audio pre-pass: decode each segment's audio to the common export layout
-		// up-front, so we know whether to declare an audio track on the muxer (mp4
-		// needs that at construction). The concatenation TIMING is applied later,
-		// once the video loop has produced each segment's real frame count.
-		const stopAudioDecode = timings.start("audioDecode");
-		const segmentAudioPcm: (Float32Array[] | null)[] = [];
-		let anySegmentAudio = false;
-		for (const segment of segments) {
-			if (this.cancelled) break;
-			const pcm = await decodeSegmentAudioPcm(
-				segment,
-				AUDIO_OUTPUT_SAMPLE_RATE,
-				AUDIO_OUTPUT_CHANNELS,
-			);
-			if (pcm && pcm.length > 0 && (pcm[0]?.length ?? 0) > 0) anySegmentAudio = true;
-			segmentAudioPcm.push(pcm);
-		}
-		stopAudioDecode();
-		const audioExportCodec = anySegmentAudio
-			? await AudioProcessor.selectSupportedExportCodec(
-					AUDIO_OUTPUT_SAMPLE_RATE,
-					AUDIO_OUTPUT_CHANNELS,
-				)
-			: null;
-		const hasAudio = Boolean(audioExportCodec);
-
-		// ffmpeg does its own muxing and writes the file, so the JS muxer only
-		// exists on the WebCodecs path.
-		let muxer: VideoMuxer | null = null;
-		if (!useNative) {
-			muxer = new VideoMuxer(this.config, hasAudio, audioExportCodec?.muxerCodec);
-			this.muxer = muxer;
-			await muxer.initialize();
-		}
-
-		const frameDuration = 1_000_000 / this.config.frameRate;
-		const maxEncodeQueue =
-			encoderPreference === "prefer-software"
-				? Math.min(this.MAX_ENCODE_QUEUE, 32)
-				: this.MAX_ENCODE_QUEUE;
-
-		// Progress estimate from the plan (no decoder metadata needed): kept
-		// virtual duration of every segment × fps.
-		const estTotalFrames = Math.max(
-			1,
-			Math.round(
-				segments.reduce((acc, s) => {
-					const intra = s.intraTrims.reduce((a, iv) => a + (iv.endSec - iv.startSec), 0);
-					const kept = Math.max(0, s.sourceEndSec - s.sourceStartSec - intra);
-					return acc + kept * this.config.frameRate;
-				}, 0),
-			),
-		);
-
-		let frameIndex = 0;
-		// Real per-segment video frame count — audio is sized from this so the
-		// concatenated audio stays locked to the (independently retimed) video.
-		const segmentFrameCounts: number[] = [];
-
-		// The video loop spends ~90% of its wall time blocked in encodeWait, so
-		// the CPU is mostly idle while frames sit in the encoder queue. The
-		// per-segment WSOLA stretch is pure CPU work and depends ONLY on
-		// segmentAudioPcm + the plan's speed regions + audio/frame-rate
-		// constants — nothing that needs segmentFrameCounts. Kick it off here
-		// so it overlaps the video loop, then await the result in the audio
-		// phase instead of paying for it serially after.
-		const stretchedPcmPromise: Promise<(Float32Array[] | null)[] | null> =
-			hasAudio && audioExportCodec && !this.cancelled
-				? (async () => {
-						const out: (Float32Array[] | null)[] = new Array(segmentAudioPcm.length).fill(null);
-						for (let i = 0; i < segmentAudioPcm.length; i++) {
-							if (this.cancelled) break;
-							// stretchSegmentAudioBySpeed is synchronous — wrapping it in an
-							// async IIFE doesn't yield by itself. Drop back to the event loop
-							// between segments so the video loop's encodeWait can actually
-							// interleave with our CPU work.
-							await new Promise((r) => setTimeout(r, 0));
-							// Retime each segment's audio PER speed sub-segment (pitch
-							// preserved) so a partial speed region only speeds up its own
-							// span, matching the video.
-							const pcm = segmentAudioPcm[i];
-							out[i] = pcm
-								? stretchSegmentAudioBySpeed(
-										pcm,
-										segments[i],
-										projectRegionsToSegmentSource(plan.speedRegions, segments[i]),
-										AUDIO_OUTPUT_SAMPLE_RATE,
-										AUDIO_OUTPUT_CHANNELS,
-										this.config.frameRate,
-									)
-								: null;
-						}
-						return out;
-					})()
-				: Promise.resolve(null);
-		// Never let a rejection go unhandled if the export throws/cancels before the
-		// await below reaches it; the await is the one that surfaces the failure.
-		stretchedPcmPromise.catch(() => {
-			// Swallowed here on purpose — see above.
-		});
-
-		for (const segment of segments) {
-			if (this.cancelled) break;
-			if (this.fatalEncoderError) throw this.fatalEncoderError;
-
-			const framesBeforeSegment = frameIndex;
-			const decoder = new StreamingVideoDecoder();
-			this.streamingDecoder = decoder;
-
-			// Per-segment webcam overlay (this asset's camera track), decoded
-			// concurrently and matched to each screen frame by source time —
-			// mirrors the legacy single-asset webcam path.
-			let webcamDecoder: StreamingVideoDecoder | null = null;
-			let webcamFrameQueue: TimestampedVideoFrameQueue | null = null;
-			let webcamDecodePromise: Promise<void> | null = null;
-			let stopWebcamDecode = false;
-
-			try {
-				const info = await decoder.loadMetadata(segment.videoUrl);
-				const segmentTrims = buildSegmentRenderTrims(segment, info.duration);
-				// Timeline effects projected to THIS segment's source time. Speed
-				// drives the decoder's frame timing; zoom/annotation are matched by
-				// each frame's source time in the renderer.
-				const segmentSpeed = projectRegionsToSegmentSource(plan.speedRegions, segment);
-				const segmentZoom = projectRegionsToSegmentSource(plan.zoomRegions, segment);
-				const segmentAnnotations = projectRegionsToSegmentSource(plan.annotationRegions, segment);
-
-				let webcamSize: { width: number; height: number } | null = null;
-				if (segment.camera) {
-					webcamDecoder = new StreamingVideoDecoder();
-					this.webcamDecoder = webcamDecoder;
-					const webcamInfo = await webcamDecoder.loadMetadata(segment.camera.videoUrl);
-					webcamSize = { width: webcamInfo.width, height: webcamInfo.height };
-					webcamFrameQueue = new TimestampedVideoFrameQueue();
-					const queue = webcamFrameQueue;
-					webcamDecodePromise = webcamDecoder
-						.decodeAll(
-							this.config.frameRate,
-							segmentTrims,
-							segmentSpeed,
-							async (webcamFrame, _exportTs, webcamSourceMs) => {
-								while (queue.length >= 12 && !this.cancelled && !stopWebcamDecode) {
-									await new Promise((resolve) => setTimeout(resolve, 2));
-								}
-								if (this.cancelled || stopWebcamDecode) {
-									webcamFrame.close();
-									return;
-								}
-								queue.enqueue(webcamFrame, webcamSourceMs);
-							},
-							onWarning,
-						)
-						.catch((error) => {
-							const err = error instanceof Error ? error : new Error(String(error));
-							this.fatalEncoderError ??= err;
-							queue.fail(err);
-						})
-						.finally(() => {
-							if (!this.cancelled) queue.close();
-						});
-				}
-
-				renderer.setSource({
-					videoWidth: segment.sourceWidth,
-					videoHeight: segment.sourceHeight,
-					webcamSize,
-					cursorRecordingData: segmentCursorRecording(plan, segment),
-					cursorScale: plan.cursor?.scale ?? 0,
-					zoomRegions: segmentZoom,
-					annotationRegions: segmentAnnotations,
-					speedRegions: segmentSpeed,
-				});
-				renderer.setCropRegion(segment.cropRegion);
-
-				await decoder.decodeAll(
-					this.config.frameRate,
-					segmentTrims,
-					segmentSpeed,
-					async (videoFrame, _exportTs, sourceTimestampMs) => {
-						let webcamFrame: VideoFrame | null = null;
-						try {
-							if (this.cancelled) return;
-							if (this.fatalEncoderError) throw this.fatalEncoderError;
-
-							const stopWebcam = timings.start("webcam");
-							webcamFrame = webcamFrameQueue
-								? await webcamFrameQueue.frameAt(sourceTimestampMs)
-								: null;
-							stopWebcam();
-							if (this.cancelled) return;
-
-							// Encoder timestamp = contiguous OUTPUT time (seamless joins);
-							// renderFrame gets SOURCE time so zoom/annotation/cursor match
-							// the frame's content even when speed retimes the segment.
-							const timestamp = frameIndex * frameDuration;
-							const stopRender = timings.start("render");
-							await renderer.renderFrame(videoFrame, sourceTimestampMs * 1000, webcamFrame);
-							stopRender();
-
-							// Gate G0: everything renderFrame queued must EXECUTE before the
-							// next timer starts, so `fence` absorbs the compositor's real cost
-							// and the stages below stop being billed for it.
-							if (gpuFence) {
-								const stopFence = timings.start("fence");
-								renderer.finishGpuWork();
-								stopFence();
-							}
-
-							if (dumpAt !== null && frameIndex === dumpAt) {
-								await dumpFrameToConsole(renderer.getCanvas(), frameIndex);
-							}
-
-							// Both paths report the same two stages so the A/B diffs stage by
-							// stage: "readback" is getting pixels off the canvas, "encodeWait" is
-							// blocking on the consumer — the encoder queue, or the credit window.
-							if (compositeOnly) {
-								// Nothing downstream: the frame was composited and is dropped, so
-								// the wall measures the compositor and nothing else.
-							} else if (extractor) {
-								const stopExtract = timings.start("readback");
-								// The GPU->CPU descent happens here, inside copyTo — not in the
-								// VideoFrame constructor, which is lazy.
-								const bytes = await extractor.extract(renderer.getCanvas());
-								stopExtract();
-
-								const stopShip = timings.start("encodeWait");
-								// IPC copies the buffer during send(), so the extractor is free to
-								// refill it as soon as this resolves. With no sink, the frame is
-								// discarded here: that IS the ceiling arm — the crossing costs zero.
-								if (sink) await sink.write(bytes);
-								stopShip();
-							} else {
-								const stopReadback = timings.start("readback");
-								const canvas = renderer.getCanvas();
-								let exportFrame: VideoFrame;
-								if (platform === "linux") {
-									const canvasCtx = canvas.getContext("2d")!;
-									const imageData = canvasCtx.getImageData(0, 0, canvas.width, canvas.height);
-									exportFrame = new VideoFrame(imageData.data.buffer, {
-										format: "RGBA",
-										codedWidth: canvas.width,
-										codedHeight: canvas.height,
-										timestamp,
-										duration: frameDuration,
-										colorSpace: {
-											primaries: "bt709",
-											transfer: "iec61966-2-1",
-											matrix: "rgb",
-											fullRange: true,
-										},
-									});
-								} else {
-									exportFrame = new VideoFrame(canvas, { timestamp, duration: frameDuration });
-								}
-								stopReadback();
-
-								const stopEncodeWait = timings.start("encodeWait");
-								try {
-									await waitForEncoderQueueSpace({
-										getQueueSize: () => this.encoder?.encodeQueueSize ?? 0,
-										maxEncodeQueue,
-										isCancelled: () => this.cancelled,
-										encoderPreference,
-									});
-								} catch (error) {
-									exportFrame.close();
-									throw error;
-								}
-								stopEncodeWait();
-
-								if (this.encoder && this.encoder.state === "configured") {
-									this.encodeQueue++;
-									const stopEncode = timings.start("encode");
-									this.encoder.encode(exportFrame, { keyFrame: frameIndex % 150 === 0 });
-									stopEncode();
-								}
-
-								exportFrame.close();
-							}
-							frameIndex++;
-							this.reportProgress({
-								currentFrame: frameIndex,
-								totalFrames: estTotalFrames,
-								percentage: Math.min(100, (frameIndex / estTotalFrames) * 100),
-								estimatedTimeRemaining: 0,
-							});
-						} finally {
-							videoFrame.close();
-							webcamFrame?.close();
-						}
-					},
-					onWarning,
-				);
-			} finally {
-				stopWebcamDecode = true;
-				webcamFrameQueue?.destroy();
-				webcamDecoder?.cancel();
-				if (webcamDecodePromise) {
-					await webcamDecodePromise.catch(() => undefined);
-				}
-				if (this.webcamDecoder === webcamDecoder) this.webcamDecoder = null;
-				decoder.destroy();
-				if (this.streamingDecoder === decoder) this.streamingDecoder = null;
-			}
-			segmentFrameCounts.push(frameIndex - framesBeforeSegment);
-		}
-
-		if (this.cancelled) {
-			// Leaves no orphaned ffmpeg behind, and unblocks anything parked on a
-			// credit that is never coming.
-			await sink?.cancel();
-			return { success: false, error: "Export cancelled" };
-		}
-		if (this.fatalEncoderError) {
-			throw this.fatalEncoderError;
-		}
-
-		// Drain the in-flight window and close ffmpeg's stdin. This is where a
-		// truncated file would come from, so it happens before anything else.
-		const stopFlush = timings.start("flush");
-		const nativeOutput = sink ? await sink.finish() : null;
-		if (this.encoder && this.encoder.state === "configured") {
-			await this.withTimeout(
-				this.encoder.flush(),
-				ENCODER_FLUSH_TIMEOUT_MS,
-				encoderPreference === "prefer-hardware"
-					? "The hardware video encoder stopped responding while finalizing the export."
-					: "The video encoder stopped responding while finalizing the export.",
-			);
-		}
-		stopFlush();
-		if (this.fatalEncoderError) {
-			throw this.fatalEncoderError;
-		}
-
-		await Promise.all(this.muxingPromises);
-		this.reportProgress({
-			currentFrame: estTotalFrames,
-			totalFrames: estTotalFrames,
-			percentage: 100,
-			estimatedTimeRemaining: 0,
-			phase: "finalizing",
-		});
-
-		// --- Audio: concatenate every segment's decoded PCM at the plan's offsets
-		// (sized from the REAL per-segment video frame counts so A/V stays locked),
-		// apply an equal-power fade at each join, then encode once and mux. The
-		// stretch was kicked off before the video loop so it overlapped the
-		// encodeWait idle time; the await below only measures the leftover
-		// (typically ~0ms on a successful overlap). ---
-		const stopAudioStretch = timings.start("audioStretch");
-		// Non-null: same gate condition (hasAudio && audioExportCodec && !cancelled)
-		// that produced a non-null promise also gates the if-block below.
-		const stretchedPcm = (await stretchedPcmPromise)!;
-		stopAudioStretch();
-
-		const stopAudioEncode = timings.start("audioEncode");
-		// The decode and the WSOLA stretch above run on BOTH paths on purpose: they
-		// share the video loop's CPU, so dropping them under native would hand the
-		// native run a speedup the shipped product will never see. Only the encode
-		// and mux are WebCodecs-only — ffmpeg will take the PCM as a second input
-		// once the A/V-lock ordering is resolved (the plan needs the real frame
-		// counts, which only exist after the loop).
-		if (hasAudio && audioExportCodec && !this.cancelled && muxer) {
-			const audioPlan = buildAudioConcatPlan(
-				segments.map((s, i) => ({
-					clipId: s.clipId,
-					outputFrameCount: segmentFrameCounts[i] ?? 0,
-					hasAudio:
-						(segmentAudioPcm[i]?.length ?? 0) > 0 && (segmentAudioPcm[i]?.[0]?.length ?? 0) > 0,
-				})),
-				{
-					frameRate: this.config.frameRate,
-					sampleRate: AUDIO_OUTPUT_SAMPLE_RATE,
-					channels: AUDIO_OUTPUT_CHANNELS,
-				},
-			);
-			const assembled = assembleConcatenatedPcm(
-				stretchedPcm.map((pcm) => ({ pcm })),
-				audioPlan,
-				{ boundaryFadeSamples: Math.round(AUDIO_OUTPUT_SAMPLE_RATE * AUDIO_BOUNDARY_FADE_SEC) },
-			);
-			this.audioProcessor = new AudioProcessor();
-			await this.audioProcessor.encodePcmToMuxer(
-				assembled,
-				AUDIO_OUTPUT_SAMPLE_RATE,
-				muxer,
-				audioExportCodec,
-			);
-		}
-
-		stopAudioEncode();
-
-		const wallMs = performance.now() - wallStart;
-		console.warn(
-			`[export perf] wall ${wallMs.toFixed(0)}ms · ${frameIndex} frames · ${(frameIndex / (wallMs / 1000)).toFixed(1)} fps\n` +
-				timings.formatSummary({ frames: frameIndex, hardwareAcceleration: encoderPreference }),
-		);
-
-		// The shadow cache only pays off on frames whose geometry is still, so its
-		// miss rate — not the wall — is what says whether a moving camera leaves the
-		// per-frame shadow in place (rendering-architecture.md §13, Step 3).
-		const shadowStats = renderer.shadowCacheStats();
-		const shadowLookups = shadowStats.hits + shadowStats.misses;
-		if (shadowLookups > 0) {
-			const missPct = ((shadowStats.misses / shadowLookups) * 100).toFixed(1);
-			console.warn(
-				`[export perf] shadow cache: ${shadowStats.hits} hits, ${shadowStats.misses} misses (${missPct}% miss of ${shadowLookups})`,
-			);
-		}
-
-		if (compositeOnly) {
-			warnings.push("Composite ceiling diagnostic: rendered only, no file was written.");
-			return { success: true, warnings };
-		}
-		if (dropFrames) {
-			warnings.push("Readback ceiling diagnostic: frames were discarded, no file was written.");
-			return { success: true, warnings };
-		}
-		if (nativeOutput) {
-			// Scaffold: ffmpeg already wrote the file, so there is no blob to hand
-			// back and the save flow does not yet know about it. The measurement is
-			// the point here; the save path lands with the WebCodecs removal.
-			warnings.push(`Native encode wrote ${nativeOutput.outputPath} (audio not muxed yet)`);
-			return { success: true, warnings };
-		}
-
-		const blob = await muxer!.finalize();
-		return { success: true, blob, warnings: warnings.length > 0 ? warnings : undefined };
-	}
-
-	private async initializeEncoder(hardwareAcceleration: HardwareAcceleration): Promise<void> {
-		this.encodeQueue = 0;
-		this.muxingPromises = [];
-		this.chunkCount = 0;
-		this.fatalEncoderError = null;
-		let videoDescription: Uint8Array | undefined;
-
-		this.encoder = new VideoEncoder({
-			output: (chunk, meta) => {
-				if (meta?.decoderConfig?.description && !videoDescription) {
-					const desc = meta.decoderConfig.description;
-					if (desc instanceof ArrayBuffer || desc instanceof SharedArrayBuffer) {
-						videoDescription = new Uint8Array(desc);
-					} else if (ArrayBuffer.isView(desc)) {
-						videoDescription = new Uint8Array(desc.buffer, desc.byteOffset, desc.byteLength);
-					}
-					this.videoDescription = videoDescription;
-				}
-
-				if (meta?.decoderConfig?.colorSpace && !this.videoColorSpace) {
-					this.videoColorSpace = meta.decoderConfig.colorSpace;
-				}
-
-				const isFirstChunk = this.chunkCount === 0;
-				this.chunkCount++;
-
-				const muxingPromise = (async () => {
-					try {
-						if (isFirstChunk && this.videoDescription) {
-							const colorSpace = this.videoColorSpace || {
-								primaries: "bt709",
-								transfer: "iec61966-2-1",
-								matrix: "rgb",
-								fullRange: true,
-							};
-
-							const metadata: EncodedVideoChunkMetadata = {
-								decoderConfig: {
-									codec: this.config.codec || "avc1.640033",
-									codedWidth: this.config.width,
-									codedHeight: this.config.height,
-									description: this.videoDescription,
-									colorSpace,
-								},
-							};
-
-							await this.muxer!.addVideoChunk(chunk, metadata);
-						} else {
-							await this.muxer!.addVideoChunk(chunk, meta);
-						}
-					} catch (error) {
-						console.error("Muxing error:", error);
-					}
-				})();
-
-				this.muxingPromises.push(muxingPromise);
-				this.encodeQueue = Math.max(0, this.encodeQueue - 1);
-			},
-			error: (error) => {
-				console.error("[VideoExporter] Encoder error:", error);
-				this.fatalEncoderError =
-					error instanceof Error ? error : new Error(`Video encoder error: ${String(error)}`);
-				this.streamingDecoder?.cancel();
-				this.webcamDecoder?.cancel();
-			},
-		});
-
-		const encoderConfig: VideoEncoderConfig = {
-			codec: this.config.codec || "avc1.640033",
-			width: this.config.width,
-			height: this.config.height,
-			bitrate: this.config.bitrate,
-			framerate: this.config.frameRate,
-			latencyMode: "quality",
-			bitrateMode: "variable",
-			hardwareAcceleration,
-		};
-
-		const support = await VideoEncoder.isConfigSupported(encoderConfig);
-		if (!support.supported) {
-			throw new Error(
-				hardwareAcceleration === "prefer-hardware"
-					? "Hardware video encoding is not supported on this system."
-					: "Software video encoding is not supported on this system.",
-			);
-		}
-
-		console.log(
-			`[VideoExporter] Using ${hardwareAcceleration === "prefer-hardware" ? "hardware" : "software"} acceleration`,
-		);
-		this.encoder.configure(encoderConfig);
-	}
-
-	cancel(): void {
-		this.cancelled = true;
-		if (this.streamingDecoder) {
-			this.streamingDecoder.cancel();
-		}
-		if (this.webcamDecoder) {
-			this.webcamDecoder.cancel();
-		}
-		if (this.audioProcessor) {
-			this.audioProcessor.cancel();
-		}
-		if (this.nativeSink) {
-			// Fire-and-forget: cancel() is sync by contract. Main kills the ffmpeg
-			// process tree, so an abandoned export leaves nothing running.
-			void this.nativeSink.cancel();
-			this.nativeSink = null;
-		}
-		this.cleanup();
-	}
-
-	private cleanup(): void {
-		if (this.encoder) {
-			try {
-				if (this.encoder.state === "configured") {
-					this.encoder.close();
-				}
-			} catch (e) {
-				console.warn("Error closing encoder:", e);
-			}
-			this.encoder = null;
-		}
-
-		if (this.streamingDecoder) {
-			try {
-				this.streamingDecoder.destroy();
-			} catch (e) {
-				console.warn("Error destroying streaming decoder:", e);
-			}
-			this.streamingDecoder = null;
-		}
-
-		if (this.webcamDecoder) {
-			try {
-				this.webcamDecoder.destroy();
-			} catch (e) {
-				console.warn("Error destroying webcam decoder:", e);
-			}
-			this.webcamDecoder = null;
-		}
-
-		if (this.renderer) {
-			try {
-				this.renderer.destroy();
-			} catch (e) {
-				console.warn("Error destroying renderer:", e);
-			}
-			this.renderer = null;
-		}
-
-		this.audioProcessor = null;
-		this.muxer = null;
-		this.encodeQueue = 0;
-		this.muxingPromises = [];
-		this.chunkCount = 0;
-		this.videoDescription = undefined;
-		this.videoColorSpace = undefined;
-		this.fatalEncoderError = null;
-	}
-
-	private getEncoderPreferences(): HardwareAcceleration[] {
-		// Hardware-first everywhere: the per-frame encode dominates export wall-time
-		// (Phase-0: encodeWait ≈ 90%), and hardware H.264 cuts it substantially. The
-		// export() retry loop falls back to prefer-software if the hardware attempt
-		// throws, so this only trades up when the hardware encoder actually works.
-		return ["prefer-hardware", "prefer-software"];
-	}
-
-	private async trySourceCopyFastPath(videoInfo: SourceCopyVideoInfo) {
-		const blockers = getSourceCopyFastPathBlockers(this.config, videoInfo);
-		if (blockers.length > 0) {
-			console.info("[VideoExporter] source-copy fast path disabled", {
-				blockers,
-				output: { width: this.config.width, height: this.config.height },
-				source: videoInfo,
-			});
-			return null;
-		}
-
-		const sourceBlob = await this.loadSourceBlob();
-		if (!sourceBlob || !isMp4Source(this.config.videoUrl, sourceBlob)) {
-			console.info("[VideoExporter] source-copy fast path disabled", {
-				blockers: ["source is not a readable MP4"],
-				source: videoInfo,
-			});
-			return null;
-		}
-
-		if (this.cancelled) {
-			return { success: false, error: "Export cancelled" };
-		}
-
-		this.reportProgress({
-			currentFrame: 1,
-			totalFrames: 1,
-			percentage: 100,
-			estimatedTimeRemaining: 0,
-			phase: "finalizing",
-		});
-		console.info("[VideoExporter] using source-copy fast path", {
-			source: videoInfo,
-			bytes: sourceBlob.size,
-		});
-
-		return {
-			success: true,
-			blob: sourceBlob.type ? sourceBlob : new Blob([sourceBlob], { type: "video/mp4" }),
-		} satisfies ExportResult;
-	}
-
-	private async loadSourceBlob() {
-		const videoUrl = this.config.videoUrl;
-		const isRemoteUrl = /^(https?:|blob:|data:)/i.test(videoUrl);
-
-		if (!isRemoteUrl && window.electronAPI?.readBinaryFile) {
-			// The source-copy fast path reads the whole file into a Blob. That is
-			// impossible for recordings above Node's 2 GiB single-read cap, so bail
-			// out and let the (streaming) re-encode path handle them instead.
-			if (window.electronAPI.getReadableFileInfo) {
-				const info = await window.electronAPI.getReadableFileInfo(videoUrl);
-				if (
-					info.success &&
-					typeof info.size === "number" &&
-					info.size > MAX_IN_MEMORY_SOURCE_BYTES
-				) {
-					return null;
-				}
-			}
-
-			const result = await window.electronAPI.readBinaryFile(videoUrl);
-			if (!result.success || !result.data) {
-				return null;
-			}
-
-			const type = videoUrl.toLowerCase().split(/[?#]/, 1)[0].endsWith(".mp4") ? "video/mp4" : "";
-			return new Blob([result.data], type ? { type } : undefined);
-		}
-
-		const response = await fetch(videoUrl);
-		if (!response.ok) {
-			return null;
-		}
-
-		return response.blob();
-	}
-
-	private reportProgress(progress: ExportProgress): void {
-		this.config.onProgress?.(progress);
-	}
-
-	private withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
-		return new Promise<T>((resolve, reject) => {
-			const timer = window.setTimeout(() => reject(new Error(message)), timeoutMs);
-			promise.then(
-				(value) => {
-					window.clearTimeout(timer);
-					resolve(value);
-				},
-				(error) => {
-					window.clearTimeout(timer);
-					reject(error);
-				},
-			);
-		});
-	}
-}
diff --git a/src/lib/exporter/wgslFrameRenderer.ts b/src/lib/exporter/wgslFrameRenderer.ts
deleted file mode 100644
index c8d4d5b87d..0000000000
--- a/src/lib/exporter/wgslFrameRenderer.ts
+++ /dev/null
@@ -1,737 +0,0 @@
-// WgslFrameRenderer — the §8b compositor, as a POC.
-//
-// Drop-in for FrameRenderer: same methods, same canvas out, so the existing
-// decode / encode / mux / audio pipeline is untouched and the bench can put the
-// two compositors in one interleaved run. That is the whole point of matching the
-// interface — a POC that cannot be measured against what it replaces is a demo.
-//
-// What it is: WebGPU device, four textures, one uniform block, one draw call
-// (plus the shadow's own passes). No Pixi, no Canvas2D, no six surfaces, no two GL
-// contexts, no per-geometry cache.
-//
-// Both seams (§8c) stay on the device: the decoded VideoFrame enters as an
-// external texture (zero copy), and the composited canvas leaves as
-// `new VideoFrame(canvas)` to the encoder. Nothing descends to CPU RAM.
-//
-// NOT in the POC: captions/annotations (glyph rasterisation — a texture upload,
-// cheap to add later), 3D rotation, the cursor. Scoped out with the user, and
-// none of them changes the shape of what is measured here.
-
-import type {
-	AnnotationRegion,
-	CameraFullscreenRegion,
-	CropRegion,
-	SpeedRegion,
-	WebcamMaskShape,
-	ZoomRegion,
-} from "@/components/video-editor/types";
-import type { Size, WebcamLayoutPreset, WebcamSizePreset } from "@/lib/compositeLayout";
-import { COMPOSITE_WGSL } from "./wgsl/composite.wgsl";
-import {
-	createEvaluateMemory,
-	type EvaluateLayout,
-	type EvaluateMemory,
-	type EvaluateScene,
-	evaluate,
-	evaluateLayout,
-	type FrameState,
-} from "./wgsl/evaluate";
-import {
-	boxesForStdDeviation,
-	SHADOW_WGSL,
-	shadowStages,
-	stdDeviationForBlur,
-} from "./wgsl/shadowCascade.wgsl";
-
-export interface WgslFrameRenderConfig {
-	width: number;
-	height: number;
-	wallpaper: string;
-	zoomRegions: ZoomRegion[];
-	cameraFullscreenRegions?: CameraFullscreenRegion[];
-	annotationRegions?: AnnotationRegion[];
-	speedRegions?: SpeedRegion[];
-	showShadow: boolean;
-	shadowIntensity: number;
-	showBlur: boolean;
-	motionBlurAmount?: number;
-	borderRadius?: number;
-	padding?: number;
-	cropRegion: CropRegion;
-	videoWidth: number;
-	videoHeight: number;
-	webcamSize?: Size | null;
-	webcamLayoutPreset?: WebcamLayoutPreset;
-	webcamMaskShape?: WebcamMaskShape;
-	webcamMirrored?: boolean;
-	webcamReactiveZoom?: boolean;
-	webcamSizePreset?: WebcamSizePreset;
-	webcamPosition?: { cx: number; cy: number } | null;
-	cursorTelemetry?: import("@/components/video-editor/types").CursorTelemetryPoint[];
-	platform: string;
-}
-
-const MASK_SHAPE_CODE: Record<string, number> = {
-	rectangle: 0,
-	rounded: 1,
-	circle: 2,
-	square: 3,
-};
-
-/** Uniform block: 28 floats = 112 bytes. §8b budgets ~200; there is room. */
-const UNIFORM_FLOATS = 28;
-
-export class WgslFrameRenderer {
-	private config: WgslFrameRenderConfig;
-	private canvas: HTMLCanvasElement | null = null;
-	private context: GPUCanvasContext | null = null;
-	private device: GPUDevice | null = null;
-
-	private compositePipeline: GPURenderPipeline | null = null;
-	private uniformBuffer: GPUBuffer | null = null;
-	private uniformData = new Float32Array(UNIFORM_FLOATS);
-	private sampler: GPUSampler | null = null;
-	private backgroundTexture: GPUTexture | null = null;
-	/** Stands in for an absent webcam: an external texture binding cannot be null. */
-	private blankTexture: GPUTexture | null = null;
-
-	private shadow: ShadowPasses | null = null;
-
-	private layout: EvaluateLayout | null = null;
-	private layoutHasWebcam: boolean | null = null;
-	private memory: EvaluateMemory = createEvaluateMemory();
-	/** WebGPU reports validation failures out-of-band: a broken pass draws nothing
-	 *  and says nothing, which reads as a fast compositor rendering black. Scoped
-	 *  on the first frame only — enough to catch a structural mistake, and the
-	 *  popErrorScope sync is not something the steady state should pay for. */
-	private firstFrame = true;
-
-	constructor(config: WgslFrameRenderConfig) {
-		this.config = config;
-	}
-
-	async initialize(): Promise<void> {
-		if (!navigator.gpu) {
-			throw new Error("WebGPU unavailable: navigator.gpu is missing (needs a secure context)");
-		}
-		const adapter = await navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
-		if (!adapter) throw new Error("WebGPU unavailable: no adapter");
-		const device = await adapter.requestDevice();
-		this.device = device;
-		// A device lost mid-export must not surface as a black frame or a silent
-		// hang: it is a failed export and must say so.
-		device.lost.then((info) => {
-			console.error(`[wgsl] GPU device lost: ${info.reason} — ${info.message}`);
-		});
-
-		const canvas = document.createElement("canvas");
-		canvas.width = this.config.width;
-		canvas.height = this.config.height;
-		this.canvas = canvas;
-
-		const context = canvas.getContext("webgpu");
-		if (!context) throw new Error("WebGPU unavailable: canvas has no webgpu context");
-		this.context = context;
-		context.configure({
-			device,
-			format: navigator.gpu.getPreferredCanvasFormat(),
-			alphaMode: "opaque",
-			// The composited texture is read back by `new VideoFrame(canvas)` — the
-			// encoder seam. Without COPY_SRC that read is illegal.
-			usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
-		});
-
-		this.sampler = device.createSampler({
-			magFilter: "linear",
-			minFilter: "linear",
-			addressModeU: "clamp-to-edge",
-			addressModeV: "clamp-to-edge",
-		});
-
-		this.uniformBuffer = device.createBuffer({
-			size: UNIFORM_FLOATS * 4,
-			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-		});
-
-		const module = device.createShaderModule({ code: COMPOSITE_WGSL, label: "composite" });
-		this.compositePipeline = device.createRenderPipeline({
-			label: "composite",
-			layout: "auto",
-			vertex: { module, entryPoint: "vs" },
-			fragment: {
-				module,
-				entryPoint: "fs",
-				targets: [{ format: navigator.gpu.getPreferredCanvasFormat() }],
-			},
-			primitive: { topology: "triangle-list" },
-		});
-
-		this.blankTexture = device.createTexture({
-			size: [1, 1],
-			format: "rgba8unorm",
-			usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
-		});
-
-		await this.loadBackground();
-
-		this.shadow = new ShadowPasses(device, this.config.width, this.config.height);
-	}
-
-	/**
-	 * The wallpaper, blurred ONCE at init.
-	 *
-	 * This is not the 2D cache in disguise: the wallpaper is a still image, so
-	 * blurring it per frame would be recomputing a constant. The shadow is not a
-	 * constant — it follows the camera — which is exactly why it is not cached.
-	 */
-	private async loadBackground(): Promise<void> {
-		const device = this.device;
-		if (!device) return;
-		const { width, height } = this.config;
-
-		const surface = document.createElement("canvas");
-		surface.width = width;
-		surface.height = height;
-		const ctx = surface.getContext("2d");
-		if (!ctx) throw new Error("2d context unavailable for wallpaper preparation");
-
-		const wallpaper = this.config.wallpaper;
-		if (wallpaper && !wallpaper.startsWith("#") && !wallpaper.includes("gradient")) {
-			const url =
-				wallpaper.startsWith("/") || wallpaper.includes("://")
-					? wallpaper
-					: `/wallpapers/${wallpaper}`;
-			try {
-				const image = await loadImage(url);
-				if (this.config.showBlur) ctx.filter = "blur(6px)";
-				ctx.drawImage(image, 0, 0, width, height);
-				ctx.filter = "none";
-			} catch (error) {
-				console.warn(`[wgsl] wallpaper ${url} failed to load, falling back to flat:`, error);
-				ctx.fillStyle = "#1e1e1e";
-				ctx.fillRect(0, 0, width, height);
-			}
-		} else {
-			ctx.fillStyle = wallpaper || "#1e1e1e";
-			ctx.fillRect(0, 0, width, height);
-		}
-
-		this.backgroundTexture = device.createTexture({
-			size: [width, height],
-			format: "rgba8unorm",
-			usage:
-				GPUTextureUsage.TEXTURE_BINDING |
-				GPUTextureUsage.COPY_DST |
-				GPUTextureUsage.RENDER_ATTACHMENT,
-		});
-		device.queue.copyExternalImageToTexture(
-			{ source: surface },
-			{ texture: this.backgroundTexture },
-			[width, height],
-		);
-	}
-
-	setSource(source: {
-		videoWidth: number;
-		videoHeight: number;
-		webcamSize?: Size | null;
-		zoomRegions?: ZoomRegion[];
-		annotationRegions?: AnnotationRegion[];
-		speedRegions?: SpeedRegion[];
-		cursorRecordingData?: unknown;
-		cursorScale?: number;
-	}): void {
-		this.config = {
-			...this.config,
-			videoWidth: source.videoWidth,
-			videoHeight: source.videoHeight,
-			webcamSize: source.webcamSize ?? null,
-			zoomRegions: source.zoomRegions ?? this.config.zoomRegions,
-			annotationRegions: source.annotationRegions ?? this.config.annotationRegions,
-			speedRegions: source.speedRegions ?? this.config.speedRegions,
-		};
-		// A new segment is a new source: geometry must be recomputed, and the
-		// spring must not integrate across the cut.
-		this.layout = null;
-		this.layoutHasWebcam = null;
-		this.memory = createEvaluateMemory();
-	}
-
-	setCropRegion(crop: CropRegion): void {
-		this.config = { ...this.config, cropRegion: crop };
-		this.layout = null;
-	}
-
-	private scene(): EvaluateScene {
-		return {
-			outputSize: { width: this.config.width, height: this.config.height },
-			videoSize: { width: this.config.videoWidth, height: this.config.videoHeight },
-			webcamSize: this.config.webcamSize ?? null,
-			cropRegion: this.config.cropRegion,
-			padding: this.config.padding ?? 0,
-			borderRadius: this.config.borderRadius ?? 0,
-			shadowIntensity: this.config.showShadow ? this.config.shadowIntensity : 0,
-			motionBlurAmount: this.config.motionBlurAmount ?? 0,
-			zoomRegions: this.config.zoomRegions,
-			cameraFullscreenRegions: this.config.cameraFullscreenRegions ?? [],
-			webcamLayoutPreset: this.config.webcamLayoutPreset ?? "picture-in-picture",
-			webcamSizePreset: this.config.webcamSizePreset ?? 25,
-			webcamMaskShape: this.config.webcamMaskShape ?? "rectangle",
-			webcamPosition: this.config.webcamPosition ?? null,
-			webcamMirrored: this.config.webcamMirrored ?? false,
-			webcamReactiveZoom: this.config.webcamReactiveZoom ?? true,
-			cursorTelemetry: this.config.cursorTelemetry,
-		};
-	}
-
-	async renderFrame(
-		videoFrame: VideoFrame,
-		timestampUs: number,
-		webcamFrame?: VideoFrame | null,
-	): Promise<void> {
-		const device = this.device;
-		const context = this.context;
-		const pipeline = this.compositePipeline;
-		if (!device || !context || !pipeline || !this.uniformBuffer || !this.sampler) {
-			throw new Error("Renderer not initialized");
-		}
-
-		const scene = this.scene();
-		const hasWebcam = !!webcamFrame;
-		if (!this.layout || this.layoutHasWebcam !== hasWebcam) {
-			this.layout = evaluateLayout(scene, hasWebcam);
-			this.layoutHasWebcam = hasWebcam;
-		}
-		if (!this.layout) throw new Error("Layout could not be evaluated");
-
-		const timeMs = timestampUs / 1000;
-		const state = evaluate(scene, this.layout, timeMs, this.memory);
-		if (this.firstFrame) {
-			device.pushErrorScope("validation");
-			console.warn(
-				`[wgsl] frame 0 @${timeMs.toFixed(0)}ms: stage ${this.config.width}x${this.config.height}` +
-					` · padding ${scene.padding} · preset ${scene.webcamLayoutPreset}` +
-					` · maskRect ${fmtRect(this.layout.maskRect)}` +
-					` · camera scale=${state.camera.scale.toFixed(3)} x=${state.camera.x.toFixed(0)} y=${state.camera.y.toFixed(0)}` +
-					` · videoRect ${fmtRect(state.cameraRect)} r=${state.cameraBorderRadius.toFixed(1)}` +
-					` · shadow ${state.shadowIntensity} · webcam ${
-						state.webcamRect ? fmtRect(state.webcamRect) : "none"
-					}`,
-			);
-		}
-
-		// Seam S1: the decoded frame becomes a texture without leaving the device.
-		// External textures are valid for this task only — imported per frame, by
-		// design, and free.
-		const videoTex = device.importExternalTexture({ source: videoFrame });
-		const webcamTex = webcamFrame ? device.importExternalTexture({ source: webcamFrame }) : null;
-
-		const encoder = device.createCommandEncoder({ label: "frame" });
-
-		let shadowView: GPUTextureView;
-		if (state.shadowIntensity > 0 && this.shadow) {
-			shadowView = this.shadow.encode(encoder, state);
-		} else {
-			shadowView = this.shadow!.outputTexture.createView();
-		}
-
-		this.writeUniforms(state, hasWebcam);
-		device.queue.writeBuffer(this.uniformBuffer, 0, this.uniformData);
-
-		const bindGroup = device.createBindGroup({
-			layout: pipeline.getBindGroupLayout(0),
-			entries: [
-				{ binding: 0, resource: { buffer: this.uniformBuffer } },
-				{ binding: 1, resource: this.sampler },
-				{ binding: 2, resource: videoTex },
-				{
-					binding: 3,
-					resource: webcamTex ?? device.importExternalTexture({ source: blankFrame() }),
-				},
-				{ binding: 4, resource: this.backgroundTexture!.createView() },
-				{ binding: 5, resource: shadowView },
-			],
-		});
-
-		const pass = encoder.beginRenderPass({
-			colorAttachments: [
-				{
-					view: context.getCurrentTexture().createView(),
-					clearValue: { r: 0, g: 0, b: 0, a: 1 },
-					loadOp: "clear",
-					storeOp: "store",
-				},
-			],
-		});
-		pass.setPipeline(pipeline);
-		pass.setBindGroup(0, bindGroup);
-		pass.draw(3);
-		pass.end();
-
-		device.queue.submit([encoder.finish()]);
-
-		if (this.firstFrame) {
-			this.firstFrame = false;
-			const error = await device.popErrorScope();
-			if (error) console.error(`[wgsl] VALIDATION ERROR on frame 0: ${error.message}`);
-			else console.warn("[wgsl] frame 0 submitted with no validation error");
-		}
-	}
-
-	/**
-	 * Pack the uniform block. Field n lives at float 4n — the struct is all vec4f
-	 * precisely so this can be true (see composite.wgsl.ts).
-	 */
-	private writeUniforms(state: FrameState, hasWebcam: boolean): void {
-		const u = this.uniformData;
-		const w = state.webcamRect;
-		// Motion blur, in pixels, along the camera's direction of travel. The 2D
-		// path drives a Pixi filter from the same velocity; same input, same look.
-		const blurPx = state.velocity * (state.motionBlurAmount ?? 0) * 400;
-
-		// a: stage.xy | videoRadius | shadowIntensity
-		u[0] = this.config.width;
-		u[1] = this.config.height;
-		u[2] = state.cameraBorderRadius;
-		u[3] = state.shadowIntensity;
-		// videoRect
-		u[4] = state.cameraRect.x;
-		u[5] = state.cameraRect.y;
-		u[6] = state.cameraRect.width;
-		u[7] = state.cameraRect.height;
-		// crop
-		u[8] = state.crop.x;
-		u[9] = state.crop.y;
-		u[10] = state.crop.width;
-		u[11] = state.crop.height;
-		// webcamRect
-		u[12] = w?.x ?? 0;
-		u[13] = w?.y ?? 0;
-		u[14] = w?.width ?? 0;
-		u[15] = w?.height ?? 0;
-		// b: webcamRadius | motionBlur.xy | unused. Blur runs along x: the camera's
-		// travel is dominated by the pan, and a single axis is what the 2D filter
-		// applies too.
-		u[16] = w?.borderRadius ?? 0;
-		u[17] = blurPx;
-		u[18] = 0;
-		u[19] = 0;
-		// flags: shape | mirrored | hasWebcam | hasShadow — floats, not u32, so the
-		// whole block is one Float32Array with no type interleaving.
-		u[20] = w ? (MASK_SHAPE_CODE[w.shape] ?? 0) : 0;
-		u[21] = state.webcamMirrored ? 1 : 0;
-		u[22] = hasWebcam && w ? 1 : 0;
-		u[23] = state.shadowIntensity > 0 ? 1 : 0;
-		// webcamSrc: the largest centred sub-rect of the camera with the BOX's aspect
-		// ratio — `object-fit: cover`, computed here because the box's ratio is not the
-		// camera's (a block layout hands it a column slot; Full Camera walks it out to
-		// the whole frame) and the shader would otherwise stretch the face into it.
-		const src = this.config.webcamSize;
-		const boxAspect = w && w.height > 0 ? w.width / w.height : 1;
-		const srcAspect = src && src.width > 0 && src.height > 0 ? src.width / src.height : boxAspect;
-		const cropW = srcAspect > boxAspect ? boxAspect / srcAspect : 1;
-		const cropH = srcAspect > boxAspect ? 1 : srcAspect / boxAspect;
-		u[24] = (1 - cropW) / 2;
-		u[25] = (1 - cropH) / 2;
-		u[26] = cropW;
-		u[27] = cropH;
-	}
-
-	getCanvas(): HTMLCanvasElement {
-		if (!this.canvas) throw new Error("Renderer not initialized");
-		return this.canvas;
-	}
-
-	/** Gate G0's fence, for arm parity with the Canvas2D renderer. */
-	finishGpuWork(): void {
-		// onSubmittedWorkDone is the device's own fence; the caller awaits nothing
-		// here because the encoder's VideoFrame(canvas) is the real sync point.
-		void this.device?.queue.onSubmittedWorkDone();
-	}
-
-	/** No cache to report. Kept so the exporter can treat both renderers alike. */
-	shadowCacheStats(): { hits: number; misses: number } {
-		return { hits: 0, misses: 0 };
-	}
-
-	destroy(): void {
-		this.backgroundTexture?.destroy();
-		this.blankTexture?.destroy();
-		this.shadow?.destroy();
-		this.uniformBuffer?.destroy();
-		this.device?.destroy();
-		this.device = null;
-		this.context = null;
-		this.canvas = null;
-	}
-}
-
-/**
- * The shadow's passes: silhouette → 3 cascade stages, each a gaussian (3 box
- * blurs, separable) then a composite → strip the silhouette.
- *
- * Six textures, allocated once. Two of them exist for a reason worth stating: a
- * pass may not read and write the same texture, and a cascade stage reads BOTH
- * its source and that source's blur. So the blur chain ping-pongs in its own pair
- * (blurA/blurB) and never touches the stage's pair (stageA/stageB) — a single
- * shared ping-pong silently overwrites the stage's source on the blur's second
- * pass, which is a black shadow and a long afternoon.
- */
-class ShadowPasses {
-	readonly outputTexture: GPUTexture;
-	private device: GPUDevice;
-	private width: number;
-	private height: number;
-	private silhouette: GPUTexture;
-	private blurA: GPUTexture;
-	private blurB: GPUTexture;
-	private stageA: GPUTexture;
-	private stageB: GPUTexture;
-	private silhouettePipeline: GPURenderPipeline;
-	private boxPipeline: GPURenderPipeline;
-	private stagePipeline: GPURenderPipeline;
-	private stripPipeline: GPURenderPipeline;
-	private sampler: GPUSampler;
-	private silhouetteBuffer: GPUBuffer;
-	private stripBuffer: GPUBuffer;
-	private boxBuffers: GPUBuffer[] = [];
-	private stageBuffers: GPUBuffer[] = [];
-	private boxCursor = 0;
-	private stageCursor = 0;
-
-	constructor(device: GPUDevice, width: number, height: number) {
-		this.device = device;
-		this.width = width;
-		this.height = height;
-
-		const make = (label: string) =>
-			device.createTexture({
-				label,
-				size: [width, height],
-				format: "rgba8unorm",
-				usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
-			});
-		this.silhouette = make("shadow-silhouette");
-		this.blurA = make("shadow-blur-a");
-		this.blurB = make("shadow-blur-b");
-		this.stageA = make("shadow-stage-a");
-		this.stageB = make("shadow-stage-b");
-		this.outputTexture = make("shadow-out");
-
-		const module = device.createShaderModule({ code: SHADOW_WGSL, label: "shadow" });
-		const target: GPUColorTargetState[] = [{ format: "rgba8unorm" }];
-		const makePipeline = (entry: string, label: string) =>
-			device.createRenderPipeline({
-				label,
-				layout: "auto",
-				vertex: { module, entryPoint: "vs" },
-				fragment: { module, entryPoint: entry, targets: target },
-				primitive: { topology: "triangle-list" },
-			});
-		this.silhouettePipeline = makePipeline("fsSilhouette", "shadow-silhouette");
-		this.boxPipeline = makePipeline("fsBox", "shadow-box");
-		this.stagePipeline = makePipeline("fsStage", "shadow-stage");
-		this.stripPipeline = makePipeline("fsStrip", "shadow-strip");
-
-		this.sampler = device.createSampler({
-			magFilter: "nearest",
-			minFilter: "nearest",
-			addressModeU: "clamp-to-edge",
-			addressModeV: "clamp-to-edge",
-		});
-		this.silhouetteBuffer = device.createBuffer({
-			size: 32,
-			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-		});
-		this.stripBuffer = device.createBuffer({
-			size: 32,
-			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-		});
-	}
-
-	private boxBuffer(): GPUBuffer {
-		// One buffer per box pass per frame: a bind group must not read a buffer
-		// that a later pass in the same submit has overwritten.
-		if (this.boxCursor >= this.boxBuffers.length) {
-			this.boxBuffers.push(
-				this.device.createBuffer({
-					size: 16,
-					usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-				}),
-			);
-		}
-		return this.boxBuffers[this.boxCursor++];
-	}
-
-	private stageBuffer(): GPUBuffer {
-		if (this.stageCursor >= this.stageBuffers.length) {
-			this.stageBuffers.push(
-				this.device.createBuffer({
-					size: 16,
-					usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-				}),
-			);
-		}
-		return this.stageBuffers[this.stageCursor++];
-	}
-
-	encode(encoder: GPUCommandEncoder, state: FrameState): GPUTextureView {
-		this.boxCursor = 0;
-		this.stageCursor = 0;
-		const device = this.device;
-		const rect = state.cameraRect;
-		const radius = state.cameraBorderRadius;
-
-		// a: stage.xy | radius | unused, then rect — vec4 each, no holes.
-		const geom = new Float32Array(8);
-		geom[0] = this.width;
-		geom[1] = this.height;
-		geom[2] = radius;
-		geom[3] = 0;
-		geom[4] = rect.x;
-		geom[5] = rect.y;
-		geom[6] = rect.width;
-		geom[7] = rect.height;
-		device.queue.writeBuffer(this.silhouetteBuffer, 0, geom);
-		device.queue.writeBuffer(this.stripBuffer, 0, geom);
-
-		// 1. The silhouette.
-		this.drawInto(encoder, this.silhouettePipeline, this.silhouette, [
-			{ binding: 0, resource: { buffer: this.silhouetteBuffer } },
-		]);
-
-		// 2. The cascade. Each stage blurs its input's alpha and composites the
-		//    input back over it — so stage k+1 shadows stage k's shadow. That
-		//    recursion is the falloff; it cannot collapse into one blur.
-		let current = this.silhouette;
-		let stageIndex = 0;
-		for (const stage of shadowStages(state.shadowIntensity)) {
-			const blurred = this.blur(encoder, current, stdDeviationForBlur(stage.blur));
-			// Alternating stage textures: dest is never `current` (the previous
-			// stage's output) and never `blurred` (which lives in the blur pair).
-			const dest = stageIndex % 2 === 0 ? this.stageA : this.stageB;
-
-			const buffer = this.stageBuffer();
-			const data = new Float32Array(4);
-			data[0] = stage.offsetY / this.height;
-			data[1] = stage.alpha;
-			device.queue.writeBuffer(buffer, 0, data);
-
-			this.drawInto(encoder, this.stagePipeline, dest, [
-				{ binding: 0, resource: { buffer } },
-				{ binding: 1, resource: this.sampler },
-				{ binding: 2, resource: current.createView() },
-				{ binding: 3, resource: blurred.createView() },
-			]);
-			current = dest;
-			stageIndex++;
-		}
-
-		// 3. Remove the silhouette; the recording covers that area itself.
-		this.drawInto(encoder, this.stripPipeline, this.outputTexture, [
-			{ binding: 0, resource: { buffer: this.stripBuffer } },
-			{ binding: 1, resource: this.sampler },
-			{ binding: 2, resource: current.createView() },
-		]);
-		return this.outputTexture.createView();
-	}
-
-	/**
-	 * One gaussian = three box blurs, per the SVG filter spec. Separable, so a
-	 * d x d box costs 2d taps rather than d².
-	 *
-	 * Ping-pongs strictly inside (blurA, blurB): `src` belongs to the caller and
-	 * is read again by the cascade stage after this returns, so it must survive.
-	 */
-	private blur(encoder: GPUCommandEncoder, src: GPUTexture, stdDeviation: number): GPUTexture {
-		const boxes = boxesForStdDeviation(stdDeviation);
-		if (boxes.length === 0) return src;
-		let current = src;
-		let pass = 0;
-		for (const box of boxes) {
-			for (const axis of [0, 1]) {
-				const dest = pass % 2 === 0 ? this.blurA : this.blurB;
-				const buffer = this.boxBuffer();
-				const data = new ArrayBuffer(16);
-				const f = new Float32Array(data, 0, 2);
-				const i = new Int32Array(data, 8, 2);
-				f[0] = axis === 0 ? 1 / this.width : 0;
-				f[1] = axis === 0 ? 0 : 1 / this.height;
-				i[0] = box.width;
-				i[1] = box.offset;
-				this.device.queue.writeBuffer(buffer, 0, data);
-				this.drawInto(encoder, this.boxPipeline, dest, [
-					{ binding: 0, resource: { buffer } },
-					{ binding: 1, resource: this.sampler },
-					{ binding: 2, resource: current.createView() },
-				]);
-				current = dest;
-				pass++;
-			}
-		}
-		return current;
-	}
-
-	private drawInto(
-		encoder: GPUCommandEncoder,
-		pipeline: GPURenderPipeline,
-		target: GPUTexture,
-		entries: GPUBindGroupEntry[],
-	): void {
-		const pass = encoder.beginRenderPass({
-			colorAttachments: [
-				{
-					view: target.createView(),
-					clearValue: { r: 0, g: 0, b: 0, a: 0 },
-					loadOp: "clear",
-					storeOp: "store",
-				},
-			],
-		});
-		pass.setPipeline(pipeline);
-		pass.setBindGroup(
-			0,
-			this.device.createBindGroup({ layout: pipeline.getBindGroupLayout(0), entries }),
-		);
-		pass.draw(3);
-		pass.end();
-	}
-
-	destroy(): void {
-		this.silhouette.destroy();
-		this.blurA.destroy();
-		this.blurB.destroy();
-		this.stageA.destroy();
-		this.stageB.destroy();
-		this.outputTexture.destroy();
-		this.silhouetteBuffer.destroy();
-		this.stripBuffer.destroy();
-		for (const b of this.boxBuffers) b.destroy();
-		for (const b of this.stageBuffers) b.destroy();
-	}
-}
-
-const fmtRect = (r: { x: number; y: number; width: number; height: number }) =>
-	`${r.x.toFixed(0)},${r.y.toFixed(0)} ${r.width.toFixed(0)}x${r.height.toFixed(0)}`;
-
-function loadImage(url: string): Promise<HTMLImageElement> {
-	return new Promise((resolve, reject) => {
-		const image = new Image();
-		image.crossOrigin = "anonymous";
-		image.onload = () => resolve(image);
-		image.onerror = () => reject(new Error(`failed to load ${url}`));
-		image.src = url;
-	});
-}
-
-let blank: VideoFrame | null = null;
-/** An external texture binding cannot be null, so an absent webcam gets 1x1 of nothing. */
-function blankFrame(): VideoFrame {
-	if (!blank) {
-		const canvas = document.createElement("canvas");
-		canvas.width = 1;
-		canvas.height = 1;
-		blank = new VideoFrame(canvas, { timestamp: 0 });
-	}
-	return blank;
-}
diff --git a/src/main.tsx b/src/main.tsx
index 5090c63538..939360e624 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -8,12 +8,6 @@ import "./index.css";
 
 const windowType = new URLSearchParams(window.location.search).get("windowType") || "";
 
-// The export bench replaces the UI entirely rather than rendering alongside it,
-// so nothing competes with the export for the GPU or the main thread.
-if (windowType === "bench") {
-	void import("./bench/runBench").then((m) => m.runBench());
-}
-
 // Reclaim multi-GB OPFS source copies left behind by a previous session (they
 // are only pruned opportunistically during the next large-file load otherwise).
 // Nothing is referenced at startup, so everything stale is safe to remove.
@@ -34,12 +28,10 @@ if (
 	document.getElementById("root")?.style.setProperty("background", "transparent");
 }
 
-if (windowType !== "bench") {
-	ReactDOM.createRoot(document.getElementById("root")!).render(
-		<React.StrictMode>
-			<I18nProvider>
-				<App />
-			</I18nProvider>
-		</React.StrictMode>,
-	);
-}
+ReactDOM.createRoot(document.getElementById("root")!).render(
+	<React.StrictMode>
+		<I18nProvider>
+			<App />
+		</I18nProvider>
+	</React.StrictMode>,
+);
diff --git a/src/native/compositorViewClient.ts b/src/native/compositorViewClient.ts
index 3380a699c9..5edca550af 100644
--- a/src/native/compositorViewClient.ts
+++ b/src/native/compositorViewClient.ts
@@ -113,14 +113,6 @@ export function destroyCompositorView(id: number): Promise<{ ok: true }> {
 	});
 }
 
-export function exportNative(outPath?: string): Promise<CompositorExportResult> {
-	return requireNativeBridgeData<CompositorExportResult>({
-		domain: "compositor",
-		action: "export",
-		payload: { outPath },
-	});
-}
-
 export function exportMultiNative(
 	clips: CompositorClipInput[],
 	outPath?: string,
diff --git a/src/native/contracts.ts b/src/native/contracts.ts
index b8518b6eb5..b2b66f8eb9 100644
--- a/src/native/contracts.ts
+++ b/src/native/contracts.ts
@@ -735,12 +735,6 @@ export type NativeBridgeRequest =
 			payload: { id: number };
 			requestId?: string;
 	  }
-	| {
-			domain: "compositor";
-			action: "export";
-			payload: { outPath?: string };
-			requestId?: string;
-	  }
 	| {
 			domain: "compositor";
 			action: "exportMulti";
diff --git a/technical-documentation/architecture/export-pipeline.md b/technical-documentation/architecture/export-pipeline.md
index 365542cea8..c2606ccf84 100644
--- a/technical-documentation/architecture/export-pipeline.md
+++ b/technical-documentation/architecture/export-pipeline.md
@@ -3,8 +3,8 @@
 The MP4 export drives the same Rust + Direct3D 11 compositor that powers the
 live preview ([preview.md](preview.md) /
 [native-compositor.md](native-compositor.md)), one segment at a time. The
-Electron renderer turns the project document into a `RenderPlan`, the
-renderer hands the plan and the per-segment source files to the napi addon
+Electron renderer turns the project document into the same `SceneDescription`
+the live preview uses plus an ordered clip list, hands both to the napi addon
 through the `compositor` IPC domain, and the addon drives `poc-d3d`'s
 `Player` + `Compositor::compose_frame` + AMF encoder + muxer to write one
 `.mp4`. The renderer only watches progress; the actual rendering does not
@@ -12,80 +12,21 @@ leave the native process. Performance numbers, the bench, and the rejected
 alternatives that drove the design live in
 [engineering/rendering-performance.md](../engineering/rendering-performance.md).
 
-GIF and the legacy browser-side path are out of scope here: GIF has no native
-encoder yet (it has its own dedicated code path in
-`src/lib/exporter/gifExporter.ts`); the legacy path is the one the
-`RenderPlan` is being migrated away from.
+GIF is out of scope here: it has no native encoder yet, so it keeps its own
+dedicated code path in `src/lib/exporter/gifExporter.ts` — the one format
+the document adapter still renders in the renderer.
 
 ```mermaid
 flowchart LR
     DOC["AxcutDocument"]
-    TSD["src/lib/ai-edition/exporter/renderPlan.ts<br/>buildRenderPlan / buildDocumentRenderPlan"]
-    RP["RenderPlan<br/>output + segments + virtual-time effects + appearance + cursor + webcam"]
+    TSD["src/native/sceneDescription.ts<br/>resolveVisibleClips / buildSceneDescription"]
+    RP["clips + SceneDescription JSON<br/>layout + effects + background + zoom + cursor + webcam"]
     ADDON["compositor_view.node addon<br/>exportMulti (Electron IPC)"]
     NATIVE["poc-d3d::live::Player<br/>Compositor::compose_frame<br/>h264_amf encoder + mux"]
     FILE["output.mp4"]
     DOC --> TSD --> RP --> ADDON --> NATIVE --> FILE
 ```
 
-## The `RenderPlan`
-
-`src/lib/ai-edition/exporter/renderPlan.ts` is the pure-logic data model that
-turns an `AxcutDocument` into an ordered, per-clip plan. `documentExporter`'s
-[`buildDocumentRenderPlan`](../../src/lib/ai-edition/exporter/documentExporter.ts)
-is the single boundary that builds it; `ExportDialog` and the bench both go
-through it. Every length that crosses the boundary is in seconds or
-fractions, every output is in fractions of the output frame, and the plan
-itself is JSON-serialisable.
-
-```ts
-interface RenderSegment {
-  clipId: string;
-  assetId: string;
-  videoUrl: string;             // toFileUrl(asset.originalPath) — the doc is self-contained
-  sourceStartSec: number;       // clip in-point in the asset's media time
-  sourceEndSec: number;
-  timelineStartSec: number;     // position on the (1:1-with-source, pre-speed) virtual timeline
-  timelineEndSec: number;
-  intraTrims: Interval[];       // trimRanges of THIS asset inside [start,end)
-  cropRegion: CropRegion;       // per-clip screen crop, fractions of the source
-  sourceWidth: number;
-  sourceHeight: number;
-  camera: { videoUrl: string; offsetMs: number } | null;  // per-asset webcam
-  cursorSamples: CursorRecordingSample[];                  // partitioned by assetId
-}
-
-interface RenderPlan {
-  output: { width, height, frameRate, bitrate, codec };
-  aspectRatioValue: number;
-  segments: RenderSegment[];                  // sorted by timelineStartSec
-  zoomRegions: ZoomRegion[];                  // VIRTUAL (output) time, no projection
-  annotationRegions: AnnotationRegion[];      // same — captions are derived + joined here
-  speedRegions: SpeedRegion[];                // same
-  appearance: RenderPlanAppearance;           // wallpaper, padding, radius, shadow, blur, motion
-  cursor: RenderPlanCursor | null;            // shared atlas + style; per-segment samples above
-  webcam: RenderPlanWebcam;                   // shared layout/style; per-segment source above
-}
-```
-
-Effects (`zoomRegions`, `annotationRegions`, `speedRegions`) live on the
-plan in **virtual** (output) time. The segment loop already tracks the
-virtual-time cursor that an earlier design tried to compute up-front by
-projecting every region onto source time — that projection is what the TS
-exporter still does for the legacy single-source renderer; the segment
-loop does not need it.
-
-The plan also carries the `codec` as a WebCodecs encoder string per
-user-facing choice (`avc1.640033` for H.264, `hvc1.1.6.L120.90` for H.265,
-`vp09.00.10.08` for VP9). The native side's AMF encoder takes those
-strings and produces the matching mp4 track family.
-
-`isIdentityFastPathEligible(plan)` is a single boolean: one segment, no
-intra-trims, identity crop, no zoom/annotation, no cursor overlay, no
-speed, and `output.size === segment.source.size` → the renderer can take a
-stream-copy / remux-only fast path. Everything else goes through the full
-decode → composite → encode round trip.
-
 ## Segment loop
 
 The renderer hands the addon `exportMulti(clips, outPath, sceneJson, params)`
@@ -133,35 +74,23 @@ and **one** encoder + muxer pair:
   The WSOLA stretch is kicked off before the video loop so it overlaps
   the encode and does not add to the wall.
 
-- **Output** is sized to the largest clip and honours the timeline's
-  selected aspect ratio. `pickReferenceDimensions` (in `renderPlan.ts`)
-  picks the largest source area, then `calculateMp4ExportSettings` maps
-  quality + source dims + aspect ratio to the encoder width / height /
-  bitrate.
-
-## Per-segment cursor
-
-`CursorRecordingSample.assetId` tags each sample, so the plan partitions
-the shared recording per segment (`cursorSamplesForAsset`,
-[`renderPlan.ts:178`](../../src/lib/ai-edition/exporter/renderPlan.ts)).
-Samples with no `assetId` belong to the primary asset — the convention that
-keeps single-asset projects rendering their cursor exactly as before.
-Untagged samples were the format before multi-asset cursor tagging
-landed; the fallback is the documented behaviour, not a heuristic.
-
-The shared parts of the cursor render — the sprite atlas and the style
-knobs (`scale`, `smoothing`, `motionBlur`, `clickBounce`, `clipToBounds`,
-`theme`) — live on `plan.cursor` once. The time-varying samples live per
-segment on `segment.cursorSamples`. A segment with no cursor samples
-renders with no cursor overlay, which is correct (the asset had no
-recording), not a gap.
+- **Output** honours the timeline's selected aspect ratio
+  (`resolveAspectRatioValue` over `getEditorSettings(document).aspectRatio` —
+  the same typed façade `buildSceneDescription` reads, so the dialog cannot
+  drift from the compositor). `ExportDialog`'s `tierOutputDims` feeds the
+  crop-aware **smallest** clip on the timeline to
+  [`calculateMp4ExportSettings`](../../src/lib/exporter/mp4ExportSettings.ts),
+  which maps quality + source dims + aspect ratio to the encoder
+  width / height / bitrate, and passes `width` / `height` to `exportMulti`.
+  Only "Source" quality targets those source dims; 720p / 1080p target a
+  fixed short side regardless.
 
 ## Output formats and codecs
 
 The native MP4 export takes `width`, `height`, `frameRate`, and `codec` as
-parameters on `exportMulti` and writes H.264 (AMF) by default. The user-
-facing codec choice (H.264 / H.265 / VP9) is mapped by `renderPlan.ts` to
-the WebCodecs encoder string the addon's AMF encoder consumes; VP9
+parameters on `exportMulti` and writes H.264 (AMF) by default. The
+user-facing codec choice crosses as the plain `ExportVideoCodec` string
+(`"h264"` / `"h265"` / `"vp9"`) in those params; VP9
 falls back to the same H.264 path on machines without a hardware VP9
 encoder (software VP9 was measured too slow and removed — see
 [native-compositor.md](native-compositor.md#known-gaps)). GIF is a
diff --git a/technical-documentation/architecture/preview.md b/technical-documentation/architecture/preview.md
index 000bd2b6c3..5748583024 100644
--- a/technical-documentation/architecture/preview.md
+++ b/technical-documentation/architecture/preview.md
@@ -16,12 +16,13 @@ and scene contract; the GPU-resident path it builds on is documented in
 (preview fluidity, bench methodology, the trade-offs that drove this design) live
 in [engineering/rendering-performance.md](../engineering/rendering-performance.md).
 
-## The two paths
+## The compositor path
 
-Two paths exist in the source tree. The native one is live; the Pixi-based second
-implementation is shipped but not reached from the editor surface.
+One compositor exists in the source tree, and it is the live one. A Pixi/WebGL
+single-canvas screen compositor was tried alongside it and removed once it was
+established that nothing mounted it.
 
-### Path A — native D3D compositor overlay (live)
+### Native D3D compositor overlay (live)
 
 Mounted as the first child of `.previewFrame` by
 [`NativeCompositorOverlay.tsx`](../../src/components/ai-edition/NativeCompositorOverlay.tsx).
@@ -60,20 +61,6 @@ addon's `LoadLibrary("avcodec-NN.dll")` resolves against the same pinned build t
 crate links against
 ([`compositorViewService.ts:206`](../../electron/native-bridge/services/compositorViewService.ts:206)).
 
-### Path B — Pixi/WebGL single-canvas screen compositor (shipped, not mounted)
-
-[`preview-compositor/PreviewCompositor.tsx`](../../src/components/ai-edition/preview-compositor/PreviewCompositor.tsx)
-is the screen-only successor that decodes straight into a Pixi `VideoSource` and
-composites video + zoom + mask in one GPU draw call. It is not mounted by the
-editor shell; `PreviewCanvas.tsx:393-411` deliberately falls back to the
-`VirtualPreview` legacy path with a comment recording why
-("`PreviewCompositor` (Pixi v8) regressed the screen preview … `setPixiReady` +
-`canvasSize === {0,0}` on mount produces a 1x1 canvas that the resize effect never
-widens"). The module stays in the tree as the route the next Pixi hardening
-attempts to revive, but no flag in this branch re-enables it. `PreviewCompositor`
-is therefore dead code today and is referenced in this doc only as the
-"two paths" it was advertised as offering; the live path is the native overlay.
-
 There is no fallback to a CPU/Canvas2D legacy compositor: before the native view
 ships a frame, only the wallpaper painted by CSS is visible, and the cursor / zoom
 DOM layers depend on the layout math (not the compositor) to know where to land.
diff --git a/technical-documentation/architecture/timeline-model.md b/technical-documentation/architecture/timeline-model.md
index b193bf7fd5..bd3ca100d3 100644
--- a/technical-documentation/architecture/timeline-model.md
+++ b/technical-documentation/architecture/timeline-model.md
@@ -157,7 +157,7 @@ in the same commit, or the project round-trips into an inconsistent state:
 | **Native preview scene** | `src/native/sceneDescription.ts` (`:489, :508, :517, :531`) | Calls `projectRegionsToSource` for every region kind before serialising to the native compositor. |
 | **Native playback sync** | `src/native/useNativePlaybackSync.ts` (`:22, :39`) | Resolves the RAW playhead through `resolveNativePosition` to feed `setActiveClip` / `presentTime`. |
 | **Native compositor overlay** | `src/components/ai-edition/NativeCompositorOverlay.tsx` (`:3, :70`) | Same — `resolveNativePosition(currentTimeSec, nativeClips, document.timeline.clips)` — to keep preview in sync with the timeline ruler. |
-| **Multi-clip export** | `src/lib/ai-edition/exporter/documentExporter.ts` (`:223, :238, :260, :265`) + `src/lib/ai-edition/exporter/renderPlan.ts` | Projects regions to source per-clip through `region-ventilation`'s `projectRegionsToSourceTime`, then walks the multi-clip render plan; identity single-clip projects are unchanged. |
+| **Multi-clip export** | `src/lib/ai-edition/exporter/documentExporter.ts` | Projects regions to source per-clip through `region-ventilation`'s `projectRegionsToSourceTime`; identity single-clip projects are unchanged. |
 | **Captions layer** | `src/lib/ai-edition/captions/cues.ts` (`:14-15` and `captionCuesToTextRegions`) | Caption cues are a derived view of the transcript; the projection to source at export goes through `projectRegionsToSourceTime` from `region-ventilation`, matching the multi-clip export path so preview and file agree. |
 | **Agent LLM tools** | `electron/ai-edition/agent-tools.ts` (`:22-26, :80-95, :560-575, :772-820, :835-880, :952, :1025`) | Writes the same shape via `anchorRegionsWithDerivedMs` / `replacePillSpan` / `resolvePillIds`; reads it through `coalesceRegionsForRuler` (`coalesceForAgent`, `:77-86`) so the model reasons in virtual seconds over whole pills. |
 
diff --git a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/jfk.txt b/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/jfk.txt
deleted file mode 100644
index 817720bca9..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/jfk.txt
+++ /dev/null
@@ -1 +0,0 @@
-And so, my fellow Americans: ask not what your country can do for you, ask what you can do for your country.
diff --git a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_0.txt b/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_0.txt
deleted file mode 100644
index 7bc870c13f..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_0.txt
+++ /dev/null
@@ -1 +0,0 @@
-MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL
diff --git a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_1.txt b/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_1.txt
deleted file mode 100644
index a913b570d5..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_1.txt
+++ /dev/null
@@ -1 +0,0 @@
-NOR IS MISTER QUILTER'S MANNER LESS INTERESTING THAN HIS MATTER
diff --git a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_2.txt b/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_2.txt
deleted file mode 100644
index 441ca81b32..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_2.txt
+++ /dev/null
@@ -1 +0,0 @@
-HE TELLS US THAT AT THIS FESTIVE SEASON OF THE YEAR WITH CHRISTMAS AND ROAST BEEF LOOMING BEFORE US SIMILES DRAWN FROM EATING AND ITS RESULTS OCCUR MOST READILY TO THE MIND
diff --git a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_3.txt b/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_3.txt
deleted file mode 100644
index 58cd29c14f..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_3.txt
+++ /dev/null
@@ -1 +0,0 @@
-HE HAS GRAVE DOUBTS WHETHER SIR FREDERICK LEIGHTON'S WORK IS REALLY GREEK AFTER ALL AND CAN DISCOVER IN IT BUT LITTLE OF ROCKY ITHACA
diff --git a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_4.txt b/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_4.txt
deleted file mode 100644
index 71c6cd642d..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/librispeech_demo_4.txt
+++ /dev/null
@@ -1 +0,0 @@
-LINNELL'S PICTURES ARE A SORT OF UP GUARDS AND AT EM PAINTINGS AND MASON'S EXQUISITE IDYLLS ARE AS NATIONAL AS A JINGO POEM MISTER BIRKET FOSTER'S LANDSCAPES SMILE AT ONE MUCH IN THE SAME WAY THAT MISTER CARKER USED TO FLASH HIS TEETH AND MISTER JOHN COLLIER GIVES HIS SITTER A CHEERFUL SLAP ON THE BACK BEFORE HE SAYS LIKE A SHAMPOOER IN A TURKISH BATH NEXT MAN
diff --git a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/two-min-clip.txt b/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/two-min-clip.txt
deleted file mode 100644
index 1cce313181..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/fixtures/refs/two-min-clip.txt
+++ /dev/null
@@ -1 +0,0 @@
-MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL NOR IS MISTER QUILTER'S MANNER LESS INTERESTING THAN HIS MATTER HE TELLS US THAT AT THIS FESTIVE SEASON OF THE YEAR WITH CHRISTMAS AND ROAST BEEF LOOMING BEFORE US SIMILES DRAWN FROM EATING AND ITS RESULTS OCCUR MOST READILY TO THE MIND HE HAS GRAVE DOUBTS WHETHER SIR FREDERICK LEIGHTON'S WORK IS REALLY GREEK AFTER ALL AND CAN DISCOVER IN IT BUT LITTLE OF ROCKY ITHACA LINNELL'S PICTURES ARE A SORT OF UP GUARDS AND AT EM PAINTINGS AND MASON'S EXQUISITE IDYLLS ARE AS NATIONAL AS A JINGO POEM MISTER BIRKET FOSTER'S LANDSCAPES SMILE AT ONE MUCH IN THE SAME WAY THAT MISTER CARKER USED TO FLASH HIS TEETH AND MISTER JOHN COLLIER GIVES HIS SITTER A CHEERFUL SLAP ON THE BACK BEFORE HE SAYS LIKE A SHAMPOOER IN A TURKISH BATH NEXT MAN IT IS OBVIOUSLY UNNECESSARY FOR US TO POINT OUT HOW LUMINOUS THESE CRITICISMS ARE HOW DELICATE IN EXPRESSION ON THE GENERAL PRINCIPLES OF ART MISTER QUILTER WRITES WITH EQUAL LUCIDITY PAINTING HE TELLS US IS OF A DIFFERENT QUALITY TO MATHEMATICS AND FINISH IN ART IS ADDING MORE FACT AS FOR ETCHINGS THEY ARE OF TWO KINDS BRITISH AND FOREIGN HE LAMENTS MOST BITTERLY THE DIVORCE THAT HAS BEEN MADE BETWEEN DECORATIVE ART AND WHAT WE USUALLY CALL PICTURES MAKES THE CUSTOMARY APPEAL TO THE LAST JUDGMENT AND REMINDS US THAT IN THE GREAT DAYS OF ART MICHAEL ANGELO WAS THE FURNISHING UPHOLSTERER NEAR THE FIRE AND THE ORNAMENTS FRED BROUGHT HOME FROM INDIA ON THE MANTEL BOARD IN FACT HE IS QUITE SEVERE ON MISTER RUSKIN FOR NOT RECOGNISING THAT A PICTURE SHOULD DENOTE THE FRAILTY OF MAN AND REMARKS WITH PLEASING COURTESY AND FELICITOUS GRACE THAT MANY PHASES OF FEELING
\ No newline at end of file
diff --git a/tools/stt-eval/whispercpp-dtw-poc/harness/CMakeLists.txt b/tools/stt-eval/whispercpp-dtw-poc/harness/CMakeLists.txt
deleted file mode 100644
index 63b44a3453..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/harness/CMakeLists.txt
+++ /dev/null
@@ -1,91 +0,0 @@
-# harness/CMakeLists.txt — build wcpp_dtw_bench_<backend> against the
-# pre-built whisper.cpp variant. One binary per backend; same source file.
-#
-# Use:
-#   cmake -B harness/build -S harness \
-#     -DCMAKE_BUILD_TYPE=Release \
-#     -DWHISPER_CPU_DIR=tools/stt-eval/whispercpp-dtw-poc/build-cpu \
-#     [-DWHISPER_VULKAN_DIR=... ] \
-#     [-DWHISPER_CUDA_DIR=...   ]
-#   cmake --build harness/build --config Release
-#
-# Only builds a backend if its directory is supplied AND the
-# corresponding `whisper.dll`/`whisper.lib` pair is present. CUDA is
-# skipped when nvidia-smi is not available (plan §3).
-
-cmake_minimum_required(VERSION 3.20)
-project(wcpp_dtw_bench CXX)
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-# Default each backend to its POC layout, in-repo. Override with -DWHISPER_<X>_DIR.
-if (NOT DEFINED WHISPER_CPU_DIR)
-  set(WHISPER_CPU_DIR "${CMAKE_CURRENT_LIST_DIR}/../build-cpu" CACHE PATH "")
-endif()
-if (NOT DEFINED WHISPER_VULKAN_DIR)
-  set(WHISPER_VULKAN_DIR "${CMAKE_CURRENT_LIST_DIR}/../build-vulkan" CACHE PATH "")
-endif()
-if (NOT DEFINED WHISPER_CUDA_DIR)
-  set(WHISPER_CUDA_DIR "${CMAKE_CURRENT_LIST_DIR}/../build-cuda" CACHE PATH "")
-endif()
-
-add_executable(wcpp_dtw_bench_cpu
-  wcpp_dtw_bench.cpp)
-target_compile_definitions(wcpp_dtw_bench_cpu
-  PRIVATE WCPP_BACKEND="cpu")
-target_include_directories(wcpp_dtw_bench_cpu PRIVATE
-  ${CMAKE_CURRENT_LIST_DIR}/../whisper.cpp/include
-  ${CMAKE_CURRENT_LIST_DIR}/../whisper.cpp/ggml/include
-  ${CMAKE_CURRENT_LIST_DIR}/../whisper.cpp/ggml/src)
-
-# whisper.cpp produces a DLL named whisper.dll + import lib whisper.lib.
-# The import lib is sufficient for static linkage; runtime needs whisper.dll.
-# We do NOT use add_subdirectory() on whisper.cpp here — those builds
-# already exist (see Phase 1 build scripts invoked from REPORT.md).
-# The harness just links against the produced whisper.dll import lib.
-
-# Concrete: find_library against <DIR>/src/whisper.lib (Windows layout
-# produced by our cmake -G Ninja builds).
-find_library(WHISPER_CPU_LIB
-  NAMES whisper.lib
-  PATHS "${WHISPER_CPU_DIR}/src" "${WHISPER_CPU_DIR}" "${WHISPER_CPU_DIR}/bin")
-if (WHISPER_CPU_LIB)
-  target_link_libraries(wcpp_dtw_bench_cpu PRIVATE ${WHISPER_CPU_LIB})
-  message(STATUS "wcpp_dtw_bench_cpu -> ${WHISPER_CPU_LIB}")
-else()
-  message(WARNING "whisper.lib (CPU) not found under ${WHISPER_CPU_DIR}; build-cpu first.")
-endif()
-
-# Optional Vulkan variant — built only if the lib is present in the dir.
-find_library(WHISPER_VULKAN_LIB
-  NAMES whisper.lib
-  PATHS "${WHISPER_VULKAN_DIR}/src" "${WHISPER_VULKAN_DIR}" "${WHISPER_VULKAN_DIR}/bin")
-if (WHISPER_VULKAN_LIB)
-  add_executable(wcpp_dtw_bench_vulkan wcpp_dtw_bench.cpp)
-  target_compile_definitions(wcpp_dtw_bench_vulkan PRIVATE WCPP_BACKEND="vulkan")
-  target_include_directories(wcpp_dtw_bench_vulkan PRIVATE
-    ${CMAKE_CURRENT_LIST_DIR}/../whisper.cpp/include
-    ${CMAKE_CURRENT_LIST_DIR}/../whisper.cpp/ggml/include
-    ${CMAKE_CURRENT_LIST_DIR}/../whisper.cpp/ggml/src)
-  target_link_libraries(wcpp_dtw_bench_vulkan PRIVATE ${WHISPER_VULKAN_LIB})
-  message(STATUS "wcpp_dtw_bench_vulkan -> ${WHISPER_VULKAN_LIB}")
-endif()
-
-# Optional CUDA variant — built only if the lib is present in the dir.
-find_library(WHISPER_CUDA_LIB
-  NAMES whisper.lib
-  PATHS "${WHISPER_CUDA_DIR}/src" "${WHISPER_CUDA_DIR}" "${WHISPER_CUDA_DIR}/bin")
-if (WHISPER_CUDA_LIB)
-  add_executable(wcpp_dtw_bench_cuda wcpp_dtw_bench.cpp)
-  target_compile_definitions(wcpp_dtw_bench_cuda PRIVATE WCPP_BACKEND="cuda")
-  target_include_directories(wcpp_dtw_bench_cuda PRIVATE
-    ${CMAKE_CURRENT_LIST_DIR}/../whisper.cpp/include
-    ${CMAKE_CURRENT_LIST_DIR}/../whisper.cpp/ggml/include
-    ${CMAKE_CURRENT_LIST_DIR}/../whisper.cpp/ggml/src)
-  target_link_libraries(wcpp_dtw_bench_cuda PRIVATE ${WHISPER_CUDA_LIB})
-  message(STATUS "wcpp_dtw_bench_cuda -> ${WHISPER_CUDA_LIB}")
-endif()
-
-# All whisper.cpp DLLs (one per backend) must be on PATH at run time.
-# We emit a tiny script that copies them next to the harness binary after build.
diff --git a/tools/stt-eval/whispercpp-dtw-poc/harness/analyze.mjs b/tools/stt-eval/whispercpp-dtw-poc/harness/analyze.mjs
deleted file mode 100644
index 9115be1e90..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/harness/analyze.mjs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Analyze a ctranslate2-server /inference response: full text, word-timestamp
-// sanity (monotonic, coverage vs clip duration), and basic stats.
-import fs from "fs";
-
-const [, , jsonPath, durationSec] = process.argv;
-const d = JSON.parse(fs.readFileSync(jsonPath, "utf8"));
-const dur = parseFloat(durationSec);
-
-let text = "";
-let words = [];
-for (const seg of d.segments || []) {
-	text += seg.text;
-	for (const w of seg.words || []) words.push(w);
-}
-
-let monotonic = true;
-let maxBacktrack = 0;
-let coverageGaps = [];
-for (let i = 1; i < words.length; i++) {
-	if (words[i].start < words[i - 1].start) {
-		monotonic = false;
-		maxBacktrack = Math.max(maxBacktrack, words[i - 1].start - words[i].start);
-	}
-	if (words[i].end < words[i].start) {
-		coverageGaps.push(`word[${i}] '${words[i].word}' end<start`);
-	}
-}
-
-const lastWordEnd = words.length ? words[words.length - 1].end : 0;
-const zeroStartCount = words.filter((w, i) => i > 0 && w.start === 0).length;
-
-console.log(
-	JSON.stringify(
-		{
-			detected_language: d.detected_language,
-			numSegments: (d.segments || []).length,
-			numWords: words.length,
-			text: text.trim(),
-			monotonic,
-			maxBacktrack,
-			lastWordEnd,
-			clipDuration: dur,
-			zeroStartCountExcludingFirst: zeroStartCount,
-			segmentsWithoutWords: (d.segments || []).filter((s) => !s.words || s.words.length === 0)
-				.length,
-		},
-		null,
-		2,
-	),
-);
diff --git a/tools/stt-eval/whispercpp-dtw-poc/harness/debug_jfk.mjs b/tools/stt-eval/whispercpp-dtw-poc/harness/debug_jfk.mjs
deleted file mode 100644
index be88b80b8b..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/harness/debug_jfk.mjs
+++ /dev/null
@@ -1,28 +0,0 @@
-// debug_jfk.mjs — Compare wcpp-cpu-fp16 vs ct2-fp16 word-by-word for jfk.wav
-import { promises as fs } from "node:fs";
-
-const a = JSON.parse(
-	await fs.readFile("tools/stt-eval/whispercpp-dtw-poc/results/wcpp_cpu_fp16_jfk.json", "utf8"),
-);
-const b = JSON.parse(
-	await fs.readFile("tools/stt-eval/whispercpp-dtw-poc/results/ct2_fp16_jfk.json", "utf8"),
-);
-const wa = a.segments[0].words;
-const wb = b.segments[0].words;
-console.log("wcpp words:", wa.length, "ct2 words:", wb.length);
-const maxN = Math.max(wa.length, wb.length);
-for (let i = 0; i < maxN; i++) {
-	const aw = wa[i] || { word: "<eof>", start: 0, end: 0 };
-	const bw = wb[i] || { word: "<eof>", start: 0, end: 0 };
-	const dw = aw.end - aw.start,
-		dc = bw.end - bw.start;
-	const dStart = Math.abs(aw.start - bw.start) * 1000;
-	const dEnd = Math.abs(aw.end - bw.end) * 1000;
-	console.log(
-		`  ${String(i).padStart(2)} ` +
-			`wcpp=${aw.word.padEnd(15)}[${aw.start.toFixed(2)},${aw.end.toFixed(2)}]  ` +
-			`ct2 =${bw.word.padEnd(15)}[${bw.start.toFixed(2)},${bw.end.toFixed(2)}]  ` +
-			`Δs=${dStart.toFixed(0).padStart(5)}ms  Δe=${dEnd.toFixed(0).padStart(5)}ms  ` +
-			`wcpp_dur=${(dw * 1000).toFixed(0).padStart(5)}ms  ct2_dur=${(dc * 1000).toFixed(0).padStart(5)}ms`,
-	);
-}
diff --git a/tools/stt-eval/whispercpp-dtw-poc/harness/extract_text.mjs b/tools/stt-eval/whispercpp-dtw-poc/harness/extract_text.mjs
deleted file mode 100644
index c4f62ec101..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/harness/extract_text.mjs
+++ /dev/null
@@ -1,5 +0,0 @@
-import fs from "fs";
-
-const [, , jsonPath] = process.argv;
-const d = JSON.parse(fs.readFileSync(jsonPath, "utf8"));
-process.stdout.write((d.segments || []).map((s) => s.text).join(""));
diff --git a/tools/stt-eval/whispercpp-dtw-poc/harness/run_ct2.mjs b/tools/stt-eval/whispercpp-dtw-poc/harness/run_ct2.mjs
deleted file mode 100644
index fd5f37dd9f..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/harness/run_ct2.mjs
+++ /dev/null
@@ -1,146 +0,0 @@
-// run_ct2.mjs — Spawn the OpenScreen CT2 server, POST each fixture to /inference
-// via curl.exe (multipart/form-data, field name 'file' — the server's
-// ctranslate2-server/src/main.cpp endpoint reads req.files.find("file")),
-// save the JSON responses and per-fixture wall-clock timings.
-//
-// Usage:
-//   node harness/run_ct2.mjs <results-dir> <mode:int8|fp16> <port> <model-dir> <fixture1> [fixture2] ...
-//
-// `mode` controls whether the server is launched with `--int8` or not.
-
-import { spawn, spawnSync } from "node:child_process";
-import { promises as fs } from "node:fs";
-import http from "node:http";
-import path from "node:path";
-import process from "node:process";
-
-const [, , resultsDir, modeArg, portArg, modelDir, ...fixtures] = process.argv;
-if (!resultsDir || !modeArg || !portArg || !modelDir || fixtures.length === 0) {
-	process.stderr.write(
-		"usage: node run_ct2.mjs <results-dir> <int8|fp16> <port> <model-dir> <fixture.wav> [...]\n",
-	);
-	process.exit(2);
-}
-const mode = modeArg === "int8" ? "int8" : modeArg === "fp16" ? "fp16" : null;
-if (!mode) {
-	process.stderr.write(`unknown mode "${modeArg}" (want int8 or fp16)\n`);
-	process.exit(2);
-}
-const port = Number.parseInt(portArg, 10);
-const serverExe =
-	"C:/Users/camil/Documents/repos/openscreen-new/electron/native/bin/win32-x64/ctranslate2-server-ctranslate2-cpu.exe";
-
-const args = ["--model", modelDir, "--port", String(port), "--host", "127.0.0.1"];
-if (mode === "int8") args.push("--int8");
-
-await fs.mkdir(resultsDir, { recursive: true });
-
-const child = spawn(serverExe, args, { stdio: ["ignore", "pipe", "pipe"] });
-child.stdout.on("data", (d) => process.stderr.write(`[ct2-server] ${d}`));
-child.stderr.on("data", (d) => process.stderr.write(`[ct2-server] ${d}`));
-
-const cleanup = () => {
-	try {
-		child.kill();
-	} catch {}
-	process.exit(1);
-};
-process.on("SIGINT", cleanup);
-process.on("SIGTERM", cleanup);
-
-async function waitForServer(timeoutMs = 30_000) {
-	const t0 = Date.now();
-	while (Date.now() - t0 < timeoutMs) {
-		const ok = await new Promise((resolve) => {
-			const req = http.request(
-				{ method: "GET", host: "127.0.0.1", port, path: "/health" },
-				(res) => {
-					res.resume();
-					resolve(res.statusCode && res.statusCode < 500);
-				},
-			);
-			req.on("error", () => resolve(false));
-			req.end();
-		});
-		if (ok) return;
-		if (child.exitCode !== null) {
-			throw new Error(`server exited early with code ${child.exitCode}`);
-		}
-		await new Promise((r) => setTimeout(r, 200));
-	}
-	throw new Error(`server did not become ready within ${timeoutMs} ms`);
-}
-
-function postFixture(wavPath) {
-	return new Promise((resolve, reject) => {
-		const r = spawnSync(
-			"curl.exe",
-			[
-				"-s",
-				"-X",
-				"POST",
-				`-w`,
-				`\n%{time_total}`,
-				`http://127.0.0.1:${port}/inference`,
-				`-F`,
-				`file=@${wavPath}`,
-				`-F`,
-				`language=en`,
-			],
-			{ encoding: "utf8", maxBuffer: 500 * 1024 * 1024, timeout: 20 * 60 * 1000 },
-		);
-		if (r.status !== 0) {
-			reject(new Error(`curl status ${r.status}: ${r.stderr.slice(0, 400)}`));
-			return;
-		}
-		const lines = r.stdout.split("\n");
-		const time_total_str = lines.at(-1);
-		const body = lines.slice(0, -1).join("\n");
-		const time_total = Number.parseFloat(time_total_str);
-		if (!Number.isFinite(time_total)) {
-			reject(new Error(`bad time_total from curl: ${time_total_str}`));
-			return;
-		}
-		resolve({ body, time_total });
-	});
-}
-
-await waitForServer().catch((e) => {
-	process.stderr.write(`server failed to start: ${e.message}\n`);
-	cleanup();
-});
-
-const timingsPath = path.join(resultsDir, `timings_${mode}.tsv`);
-const timingsLines = ["fixture\taudio_s\twallclock_s\trtf"];
-
-for (const fixture of fixtures) {
-	const wavPath = path.resolve(fixture);
-	const name = path.basename(wavPath, path.extname(wavPath));
-	const stat = await fs.stat(wavPath);
-	const samples = stat.size / 2; // PCM16 mono ⇒ 2 bytes/sample
-	const audio_s = samples / 16000;
-
-	let body;
-	let wall_s;
-	try {
-		({ body, time_total: wall_s } = await postFixture(wavPath));
-	} catch (e) {
-		process.stderr.write(`FAIL ${name}: ${e.message}\n`);
-		continue;
-	}
-	const rtf = wall_s / audio_s;
-
-	const outPath = path.join(resultsDir, `ct2_${mode}_${name}.json`);
-	await fs.writeFile(outPath, body);
-	timingsLines.push(`${name}\t${audio_s.toFixed(4)}\t${wall_s.toFixed(4)}\t${rtf.toFixed(4)}`);
-	process.stdout.write(
-		`ct2 ${mode} ${name}: wall=${wall_s.toFixed(3)}s audio=${audio_s.toFixed(3)}s rtf=${rtf.toFixed(3)}\n`,
-	);
-}
-
-await fs.writeFile(timingsPath, timingsLines.join("\n") + "\n");
-process.stdout.write(`wrote ${timingsPath}\n`);
-
-child.kill();
-await new Promise((r) => setTimeout(r, 200));
-process.exit(0);
diff --git a/tools/stt-eval/whispercpp-dtw-poc/harness/run_wcpp.mjs b/tools/stt-eval/whispercpp-dtw-poc/harness/run_wcpp.mjs
deleted file mode 100644
index 8c5f31b389..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/harness/run_wcpp.mjs
+++ /dev/null
@@ -1,70 +0,0 @@
-// run_wcpp.mjs — Spawn wcpp_dtw_bench_<backend>, write JSON (UTF-8),
-// then run analyze.mjs and extract_text.mjs and save artefacts.
-//
-// Usage:
-//   node harness/run_wcpp.mjs <results-dir> <backend:cpu|vulkan|cuda>
-//       <model.bin> <path/to/wcpp_dtw_bench_<backend>>
-//       <fixture.wav> [...]
-
-import { spawn, spawnSync } from "node:child_process";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import process from "node:process";
-
-const [, , resultsDir, backend, modelPath, benchExe, ...fixtures] = process.argv;
-if (!resultsDir || !backend || !modelPath || !benchExe || fixtures.length === 0) {
-	process.stderr.write(
-		"usage: node run_wcpp.mjs <results-dir> <backend> <model.bin> <bench-exe> <fixture.wav> [...]\n",
-	);
-	process.exit(2);
-}
-
-const precTag = modelPath.includes("q8_0") ? "q8_0" : "fp16";
-await fs.mkdir(resultsDir, { recursive: true });
-
-const timingsPath = path.join(resultsDir, `timings_wcpp_${backend}_${precTag}.tsv`);
-const lines = ["fixture\taudio_s\twallclock_s\trtf"];
-
-for (const fixture of fixtures) {
-	const wav = path.resolve(fixture);
-	const name = path.basename(wav, path.extname(wav));
-	const stat = await fs.stat(wav);
-	const audio_s = stat.size / 2 / 16000; // PCM16 mono
-
-	const r = spawnSync(benchExe, [modelPath, wav], {
-		encoding: "buffer",
-		maxBuffer: 500 * 1024 * 1024,
-		timeout: 30 * 60 * 1000,
-	});
-	const stderr = r.stderr.toString("utf8");
-	const stdout = r.stdout;
-	const guardrailLine =
-		stderr
-			.split(/\r?\n/)
-			.reverse()
-			.find((l) => l.includes("§4.1 guardrail")) || "(no guardrail line in stderr)";
-	if (r.status !== 0) {
-		process.stderr.write(`FAIL ${name}: exit ${r.status} — ${guardrailLine}\n${stderr}`);
-		continue;
-	}
-
-	const jsonPath = path.join(resultsDir, `wcpp_${backend}_${precTag}_${name}.json`);
-	await fs.writeFile(jsonPath, stdout);
-	// We trust the harness's own elapsed_s — read it from JSON. `rtf` below is
-	// recomputed from it rather than taken from the report.
-	let wall_s = NaN;
-	try {
-		const parsed = JSON.parse(stdout.toString("utf8"));
-		wall_s = parsed.timing?.elapsed_s ?? NaN;
-	} catch (e) {
-		process.stderr.write(`WARN ${name}: JSON parse failed: ${e.message}\n`);
-	}
-	const rtf = Number.isFinite(wall_s) && audio_s > 0 ? wall_s / audio_s : NaN;
-	lines.push(`${name}\t${audio_s.toFixed(4)}\t${wall_s.toFixed(4)}\t${rtf.toFixed(4)}`);
-	process.stdout.write(
-		`wcpp ${backend} ${precTag} ${name}: wall=${wall_s.toFixed(3)}s audio=${audio_s.toFixed(3)}s rtf=${rtf.toFixed(3)} | ${guardrailLine.trim()}\n`,
-	);
-}
-
-await fs.writeFile(timingsPath, lines.join("\n") + "\n", "utf8");
-process.stdout.write(`wrote ${timingsPath}\n`);
diff --git a/tools/stt-eval/whispercpp-dtw-poc/harness/score_all.mjs b/tools/stt-eval/whispercpp-dtw-poc/harness/score_all.mjs
deleted file mode 100644
index 970661ef28..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/harness/score_all.mjs
+++ /dev/null
@@ -1,354 +0,0 @@
-// score_all.mjs — For every (engine, mode) JSON in results/, compute
-//   - WER vs fixtures/refs/<name>.txt
-//   - analyze.mjs-style stats (monotonic, lastWordEnd <= duration, etc.)
-// Then compute the §5.1 word-timestamp head-to-head
-//   - fp16-vs-fp16: wcpp_cpu_fp16 vs ct2_fp16
-//   - q8_0-vs-int8 : wcpp_cpu_q8_0 vs ct2_int8
-// Output:
-//   - results/wer_table.tsv
-//   - results/timestamp_headtohead.json  (median/p90, gross disagreements)
-
-import { spawnSync } from "node:child_process";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import process from "node:process";
-
-const ROOT = process.cwd();
-const POC = path.join(ROOT, "tools", "stt-eval", "whispercpp-dtw-poc");
-const RESULTS = path.join(POC, "results");
-const REFS = path.join(POC, "fixtures", "refs");
-const HARNESS = path.join(POC, "harness");
-
-const audioDur = {
-	jfk: 11.002,
-	librispeech_demo_0: 5.851,
-	librispeech_demo_1: 4.438,
-	librispeech_demo_2: 11.967,
-	librispeech_demo_3: 9.5,
-	librispeech_demo_4: 29.13,
-	"two-min-clip": 130.324,
-};
-
-const isWindows = process.platform === "win32";
-const nodeBin = isWindows ? "node.exe" : "node";
-
-function runNode(script, args) {
-	return spawnSync(nodeBin, [path.join(HARNESS, script), ...args], {
-		encoding: "utf8",
-		maxBuffer: 50 * 1024 * 1024,
-	});
-}
-
-function normalizeWord(w) {
-	return w
-		.toUpperCase()
-		.replace(/[.,!?;:"“”‘’]/g, "")
-		.replace(/-/g, " ")
-		.trim();
-}
-
-// Flatten a JSON's segments[].words[] into a single ordered word list.
-function flattenWords(json) {
-	const out = [];
-	for (const seg of json.segments || []) {
-		for (const w of seg.words || []) {
-			out.push({ word: w.word, start: w.start, end: w.end, probability: w.probability });
-		}
-	}
-	return out;
-}
-
-// Per-fixture WER + analyze.
-const runs = []; // { run, fixture, jsonPath, refPath, audio_s, hyp, ref, edits, refWords, wer, monotonic, maxBacktrack, lastWordEnd, numWords, numSegments, segmentsWithoutWords, zeroStartCountExcludingFirst }
-
-// Read the CT2 timings directly from the timings_*.tsv files, since the
-// CT2 server's JSON response has no `timing` field.
-async function readTimingsTsv(name) {
-	const p = path.join(RESULTS, name);
-	if (!(await fs.stat(p).catch(() => null))) return {};
-	const text = await fs.readFile(p, "utf8");
-	const out = {};
-	for (const line of text.split(/\r?\n/)) {
-		const m = line.match(/^(\S+)\t([\d.]+)\t([\d.]+)\t([\d.]+)/);
-		if (m) out[m[1]] = { audio_s: +m[2], wall_s: +m[3], rtf: +m[4] };
-	}
-	return out;
-}
-const ct2Timings = await readTimingsTsv("timings_int8.tsv");
-const ct2Fp16Timings = await readTimingsTsv("timings_fp16.tsv");
-const wcppCpuFp16 = await readTimingsTsv("timings_wcpp_cpu_fp16.tsv");
-const wcppCpuQ80 = await readTimingsTsv("timings_wcpp_cpu_q8_0.tsv");
-const wcppVulkanFp16 = await readTimingsTsv("timings_wcpp_vulkan_fp16.tsv");
-const wcppVulkanQ80 = await readTimingsTsv("timings_wcpp_vulkan_q8_0.tsv");
-
-const jsonFiles = (await fs.readdir(RESULTS))
-	.filter((f) => f.endsWith(".json") && !f.endsWith("error.json"))
-	.sort();
-
-for (const jf of jsonFiles) {
-	const mCt = jf.match(/^(ct2)_(int8|fp16)_(.+)\.json$/);
-	const mWc = jf.match(/^(wcpp)_(cpu|vulkan|cuda)_(fp16|q8_0)_(.+)\.json$/);
-	let engine, kind, prec, fixture;
-	if (mCt) {
-		engine = mCt[1];
-		kind = mCt[2];
-		prec = mCt[2];
-		fixture = mCt[3];
-	} else if (mWc) {
-		engine = mWc[1];
-		kind = mWc[2];
-		prec = mWc[3];
-		fixture = mWc[4];
-	} else {
-		continue;
-	}
-	if (!audioDur[fixture]) continue;
-	const refPath = path.join(REFS, `${fixture}.txt`);
-	if (!(await fs.stat(refPath).catch(() => null))) continue;
-
-	const jsonPath = path.join(RESULTS, jf);
-	const json = JSON.parse(await fs.readFile(jsonPath, "utf8"));
-
-	// Pull the engine-measured timing from the TSV rather than from the JSON,
-	// because CT2 JSON has no `timing` field and wcpp JSON `audio_s` is just
-	// a re-derivation of the WAV header.
-	let timing = { audio_s: undefined, wall_s: undefined, rtf: undefined };
-	if (engine === "wcpp") {
-		const t =
-			kind === "cpu" && prec === "fp16"
-				? wcppCpuFp16
-				: kind === "cpu" && prec === "q8_0"
-					? wcppCpuQ80
-					: kind === "vulkan" && prec === "fp16"
-						? wcppVulkanFp16
-						: kind === "vulkan" && prec === "q8_0"
-							? wcppVulkanQ80
-							: {};
-		if (t[fixture]) timing = t[fixture];
-	} else if (engine === "ct2") {
-		const t = prec === "int8" ? ct2Timings : ct2Fp16Timings;
-		if (t[fixture]) timing = t[fixture];
-	}
-
-	// WER
-	const extract = runNode("extract_text.mjs", [jsonPath]);
-	if (extract.status !== 0) continue;
-	const hyp = extract.stdout;
-	const werOut = runNode("wer.mjs", [refPath, hyp]);
-	const wer = JSON.parse(werOut.stdout);
-
-	// analyze — patch the JSON before passing to analyze.mjs to drop
-	// broken timestamps (CT2 jfk: trailing segment emits word "you" with
-	// start/end = 3.69e+17 because of an uninitialised timestamp variable
-	// in ctranslate2-server/src/main.cpp when the trailing silences form
-	// a 1-word segment).
-	const patchedPath = path.join(RESULTS, `_patched_${jf}`);
-	const patched = {
-		...json,
-		segments: (json.segments || []).map((seg) => ({
-			...seg,
-			words: (seg.words || []).filter(
-				(w) => Number.isFinite(w.start) && Number.isFinite(w.end) && w.start < 1e6 && w.end < 1e6,
-			),
-		})),
-	};
-	await fs.writeFile(patchedPath, JSON.stringify(patched), "utf8");
-	const aOut = runNode("analyze.mjs", [patchedPath, String(audioDur[fixture])]);
-	const a = JSON.parse(aOut.stdout);
-	await fs.unlink(patchedPath).catch(() => {});
-
-	runs.push({
-		run: jf.replace(/\.json$/, ""),
-		engine,
-		kind,
-		prec,
-		fixture,
-		refWords: wer.refWords,
-		edits: wer.edits,
-		wer: wer.wer,
-		numWords: a.numWords,
-		numSegments: a.numSegments,
-		monotonic: a.monotonic,
-		maxBacktrack: a.maxBacktrack,
-		lastWordEnd: a.lastWordEnd,
-		clipDuration: a.clipDuration,
-		zeroStartCount: a.zeroStartCountExcludingFirst,
-		segmentsWithoutWords: a.segmentsWithoutWords,
-		rtf: timing.rtf,
-		wall_s: timing.wall_s,
-		audio_s: timing.audio_s,
-	});
-}
-
-// WER table (TSV).
-const werHeader = [
-	"run",
-	"engine",
-	"backend",
-	"prec",
-	"fixture",
-	"audio_s",
-	"rtf",
-	"refWords",
-	"edits",
-	"wer",
-	"numWords",
-	"numSegments",
-	"monotonic",
-	"maxBacktrack",
-	"lastWordEnd",
-	"zeroStartCount",
-	"segmentsWithoutWords",
-];
-const werLines = [werHeader.join("\t")];
-for (const r of runs) {
-	werLines.push(
-		[
-			r.run,
-			r.engine,
-			r.kind,
-			r.prec,
-			r.fixture,
-			r.audio_s?.toFixed?.(4) ?? "",
-			r.rtf?.toFixed?.(4) ?? "",
-			r.refWords,
-			r.edits,
-			r.wer?.toFixed?.(4) ?? "",
-			r.numWords,
-			r.numSegments,
-			r.monotonic,
-			r.maxBacktrack?.toFixed?.(3),
-			r.lastWordEnd?.toFixed?.(3),
-			r.zeroStartCount,
-			r.segmentsWithoutWords,
-		].join("\t"),
-	);
-}
-await fs.writeFile(path.join(RESULTS, "wer_table.tsv"), werLines.join("\n") + "\n", "utf8");
-process.stdout.write(`wrote ${path.join(RESULTS, "wer_table.tsv")} (${runs.length} rows)\n`);
-
-// §5.1 head-to-head: align words by normalized text, then per-word |Δ start| / |Δ end|.
-// We compute FOUR separate deltas, because wcpp t_dtw is the "moment of
-// emission" (= roughly CT2's word END) rather than the start of the audio
-// range (= CT2's word START), so direct start↔start comparison is unfair.
-//   * dStart       = |wcpp.start − ct2.start|  (apples-to-apples if both are word audio ranges)
-//   * dEnd         = |wcpp.end   − ct2.end|
-//   * dWcppStartToCt2End = |wcpp.start − ct2.end|   (if wcpp t_dtw tracks CT2's word end, this should be ~0)
-//   * dWcppMidToCt2Mid   = |wcpp.midpoint − ct2.midpoint|
-async function alignHeadToHead(precA, precB) {
-	const byFixture = new Map();
-	for (const r of runs) {
-		if (r.engine === "wcpp" && r.prec === precA) {
-			const e = byFixture.get(r.fixture) || {};
-			e.a = r;
-			byFixture.set(r.fixture, e);
-		}
-	}
-	for (const r of runs) {
-		if (r.engine === "ct2" && r.kind === precB) {
-			const e = byFixture.get(r.fixture) || {};
-			e.b = r;
-			byFixture.set(r.fixture, e);
-		}
-	}
-	const dStart = [],
-		dEnd = [],
-		dWcppStartToCt2End = [],
-		dWcppMidToCt2Mid = [];
-	const gross = [];
-	for (const [fixture, { a, b }] of byFixture.entries()) {
-		if (!a || !b) continue;
-		const jsonA = JSON.parse(await fs.readFile(path.join(RESULTS, `${a.run}.json`), "utf8"));
-		const jsonB = JSON.parse(await fs.readFile(path.join(RESULTS, `${b.run}.json`), "utf8"));
-		const wordsA = flattenWords(jsonA)
-			.map((w) => ({ ...w, _key: normalizeWord(w.word) }))
-			.filter((w) => w._key);
-		const wordsB = flattenWords(jsonB)
-			.map((w) => ({ ...w, _key: normalizeWord(w.word) }))
-			.filter((w) => w._key);
-		let i = 0,
-			j = 0;
-		while (i < wordsA.length && j < wordsB.length) {
-			if (wordsA[i]._key === wordsB[j]._key) {
-				const ds = Math.abs(wordsA[i].start - wordsB[j].start) * 1000;
-				const de = Math.abs(wordsA[i].end - wordsB[j].end) * 1000;
-				const dwx = Math.abs(wordsA[i].start - wordsB[j].end) * 1000;
-				const dmid =
-					Math.abs((wordsA[i].start + wordsA[i].end) / 2 - (wordsB[j].start + wordsB[j].end) / 2) *
-					1000;
-				dStart.push(ds);
-				dEnd.push(de);
-				dWcppStartToCt2End.push(dwx);
-				dWcppMidToCt2Mid.push(dmid);
-				if (ds > 200 || de > 200) {
-					gross.push({
-						fixture,
-						word: wordsA[i]._key,
-						wcpp: { s: wordsA[i].start, e: wordsA[i].end },
-						ct2: { s: wordsB[j].start, e: wordsB[j].end },
-						ds,
-						de,
-					});
-				}
-				i++;
-				j++;
-			} else {
-				i++;
-			}
-		}
-	}
-	function pct(arr, q) {
-		if (!arr.length) return null;
-		const s = [...arr].sort((a, b) => a - b);
-		const idx = Math.min(s.length - 1, Math.floor(s.length * q));
-		return s[idx];
-	}
-	return {
-		count: dStart.length,
-		dStart_median_ms: pct(dStart, 0.5),
-		dStart_p90_ms: pct(dStart, 0.9),
-		dStart_max_ms: Math.max(...dStart, 0),
-		dEnd_median_ms: pct(dEnd, 0.5),
-		dEnd_p90_ms: pct(dEnd, 0.9),
-		dEnd_max_ms: Math.max(...dEnd, 0),
-		dWcppStartToCt2End_median_ms: pct(dWcppStartToCt2End, 0.5),
-		dWcppStartToCt2End_p90_ms: pct(dWcppStartToCt2End, 0.9),
-		dWcppMidToCt2Mid_median_ms: pct(dWcppMidToCt2Mid, 0.5),
-		dWcppMidToCt2Mid_p90_ms: pct(dWcppMidToCt2Mid, 0.9),
-		gross_count: gross.length,
-		gross_examples: gross.slice(0, 20),
-	};
-}
-
-const h_fp16_vs_fp16 = await alignHeadToHead("fp16", "fp16");
-const h_q8_0_vs_int8 = await alignHeadToHead("q8_0", "int8");
-
-const headToHead = {
-	"fp16-vs-fp16 (wcpp_cpu_fp16 vs ct2_fp16)": h_fp16_vs_fp16,
-	"q8_0-vs-int8 (wcpp_cpu_q8_0 vs ct2_int8)": h_q8_0_vs_int8,
-};
-await fs.writeFile(
-	path.join(RESULTS, "timestamp_headtohead.json"),
-	JSON.stringify(headToHead, null, 2),
-	"utf8",
-);
-process.stdout.write(`wrote ${path.join(RESULTS, "timestamp_headtohead.json")}\n`);
-
-// Console summary
-process.stdout.write("\n=== WER (smaller is better, 0 = perfect) ===\n");
-for (const r of runs) {
-	process.stdout.write(
-		`${r.run.padEnd(34)}  refWords=${String(r.refWords).padStart(3)}  edits=${String(r.edits).padStart(3)}  wer=${(r.wer ?? 0).toFixed(4)}  rtf=${(r.rtf ?? 0).toFixed(3)}  monotonic=${r.monotonic}  numWords=${r.numWords}/${r.numSegments}\n`,
-	);
-}
-process.stdout.write("\n=== §5.1 Word-timestamp head-to-head (4 metrics) ===\n");
-for (const [k, v] of Object.entries(headToHead)) {
-	process.stdout.write(
-		`${k}  (n=${v.count}):\n` +
-			`   Δstart (wcpp.start vs ct2.start):           median=${v.dStart_median_ms?.toFixed(0).padStart(5)}ms  p90=${v.dStart_p90_ms?.toFixed(0).padStart(5)}ms  max=${v.dStart_max_ms?.toFixed(0).padStart(6)}ms\n` +
-			`   Δend   (wcpp.end   vs ct2.end):             median=${v.dEnd_median_ms?.toFixed(0).padStart(5)}ms  p90=${v.dEnd_p90_ms?.toFixed(0).padStart(5)}ms  max=${v.dEnd_max_ms?.toFixed(0).padStart(6)}ms\n` +
-			`   ΔwcppStart↔ct2End   (t_dtw ≈ word-end?):    median=${v.dWcppStartToCt2End_median_ms?.toFixed(0).padStart(5)}ms  p90=${v.dWcppStartToCt2End_p90_ms?.toFixed(0).padStart(5)}ms\n` +
-			`   Δmid    (wcpp.mid   vs ct2.mid):            median=${v.dWcppMidToCt2Mid_median_ms?.toFixed(0).padStart(5)}ms  p90=${v.dWcppMidToCt2Mid_p90_ms?.toFixed(0).padStart(5)}ms\n` +
-			`   gross(>200ms any): ${v.gross_count}\n`,
-	);
-}
diff --git a/tools/stt-eval/whispercpp-dtw-poc/harness/wcpp_dtw_bench.cpp b/tools/stt-eval/whispercpp-dtw-poc/harness/wcpp_dtw_bench.cpp
deleted file mode 100644
index a8f6a50bc4..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/harness/wcpp_dtw_bench.cpp
+++ /dev/null
@@ -1,364 +0,0 @@
-// wcpp_dtw_bench.cpp — whisper.cpp DTW word-timestamp benchmark.
-//
-// Usage:
-//   wcpp_dtw_bench <model.bin> <audio-16k-mono.wav> [--lang en]
-//
-// Emits ONE JSON object on stdout matching OpenScreen's transcription contract
-// shape so harness/{wer,analyze,extract_text}.mjs work unchanged:
-//   { "text": "...",
-//     "segments": [ { "id": <>, "start": S, "end": E, "text": "...",
-//                     "words": [ {"word":"...","start":s,"end":e,"probability":p}, ... ] } ],
-//     "detected_language": "en",
-//     "backend": "whispercpp-<cpu|vulkan|cuda>",
-//     "timing": { "elapsed_s": <>, "audio_s": <>, "rtf": <elapsed/audio> } }
-//
-// KEY DTW SETTINGS (the fix vs the 2024 failure):
-//   dtw_token_timestamps = true
-//   dtw_aheads_preset    = WHISPER_AHEADS_SMALL    (multilingual small)
-//   token_timestamps     = true
-// And we read whisper_token_data.t_dtw directly. Units are centiseconds
-// (1 unit = 10 ms) → seconds = t_dtw / 100.0.
-//
-// The §4.1 guardrail runs first: if t_dtw == -1 for any non-special token,
-// or the absolute-delta sum Σ|t_dtw − t0| over non-special tokens is zero
-// (DTW identical to heuristic), or t_dtw is not monotonic non-decreasing,
-// we exit non-zero before producing the JSON. The harness stays self-trustworthy.
-//
-// The backend name ("cpu"|"vulkan"|"cuda") is taken from the WCPP_BACKEND
-// preprocessor define (set by the CMakeLists for each build variant).
-
-#include "whisper.h"
-
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <cstdint>
-#include <cstring>
-#include <chrono>
-#include <fstream>
-#include <iostream>
-#include <sstream>
-#include <string>
-#include <thread>
-#include <tuple>
-#include <vector>
-
-#ifndef WCPP_BACKEND
-#define WCPP_BACKEND "cpu"
-#endif
-
-namespace {
-
-std::string json_escape(const std::string& s) {
-	std::string out;
-	out.reserve(s.size() + 8);
-	for (unsigned char c : s) {
-		switch (c) {
-			case '"':  out += "\\\""; break;
-			case '\\': out += "\\\\"; break;
-			case '\n': out += "\\n";  break;
-			case '\r': out += "\\r";  break;
-			case '\t': out += "\\t";  break;
-			default:
-				if (c < 0x20) {
-					char buf[8];
-					std::snprintf(buf, sizeof(buf), "\\u%04x", c);
-					out += buf;
-				} else {
-					out += static_cast<char>(c);
-				}
-		}
-	}
-	return out;
-}
-
-// Minimal WAV reader: PCM16, any channel count, any sample rate we record.
-// Fixtures are guaranteed PCM16 mono 16 kHz per the harness contract.
-bool read_wav_pcm16(const std::string& path, std::vector<float>& pcm, int& sample_rate_out,
-                    int& channels_out) {
-	std::ifstream f(path, std::ios::binary);
-	if (!f) { std::cerr << "cannot open " << path << "\n"; return false; }
-
-	auto read_u32 = [&]()-> uint32_t {
-		uint32_t v = 0; f.read(reinterpret_cast<char*>(&v), 4); return v;
-	};
-	auto read_u16 = [&]()-> uint16_t {
-		uint16_t v = 0; f.read(reinterpret_cast<char*>(&v), 2); return v;
-	};
-	auto read_i16 = [&]()-> int16_t {
-		int16_t v = 0; f.read(reinterpret_cast<char*>(&v), 2); return v;
-	};
-
-	char tag[4];
-	f.read(tag, 4);
-	if (f.gcount() != 4 || std::memcmp(tag, "RIFF", 4) != 0) { std::cerr << "not RIFF\n"; return false; }
-	(void)read_u32();
-	f.read(tag, 4);
-	if (std::memcmp(tag, "WAVE", 4) != 0) { std::cerr << "not WAVE\n"; return false; }
-
-	uint16_t fmt_format = 0, fmt_channels = 0, fmt_bits = 0;
-	uint32_t fmt_sample_rate = 0;
-	bool got_fmt = false;
-
-	while (f) {
-		char chunk_tag[4];
-		f.read(chunk_tag, 4);
-		if (f.gcount() != 4) break;
-		const uint32_t chunk_size = read_u32();
-		if (std::memcmp(chunk_tag, "fmt ", 4) == 0) {
-			fmt_format      = read_u16();
-			fmt_channels    = read_u16();
-			fmt_sample_rate = read_u32();
-			(void)read_u32();      // byte rate
-			(void)read_u16();      // block align
-			fmt_bits        = read_u16();
-			const uint32_t fmt_extra = chunk_size - 16;
-			if (fmt_extra) f.seekg(fmt_extra, std::ios::cur);
-			got_fmt = true;
-		} else if (std::memcmp(chunk_tag, "data", 4) == 0) {
-			if (!got_fmt || fmt_format != 1 || fmt_bits != 16) {
-				std::cerr << "expected PCM16, got format=" << fmt_format
-				          << " bits=" << fmt_bits << "\n";
-				return false;
-			}
-			sample_rate_out = static_cast<int>(fmt_sample_rate);
-			channels_out    = fmt_channels;
-			const size_t frames = chunk_size / 2 / fmt_channels;
-			pcm.resize(frames);
-			if (fmt_channels == 1) {
-				for (size_t i = 0; i < frames; ++i) pcm[i] = static_cast<float>(read_i16()) / 32768.0f;
-			} else {
-				std::vector<int> count(frames, 0);
-				for (size_t ch = 0; ch < fmt_channels; ++ch) {
-					for (size_t i = 0; i < frames; ++i) {
-						pcm[i] += static_cast<float>(read_i16()) / 32768.0f;
-						++count[i];
-					}
-				}
-				for (size_t i = 0; i < frames; ++i) pcm[i] /= count[i];
-			}
-			return true;
-		} else {
-			f.seekg(chunk_size + (chunk_size & 1), std::ios::cur);
-		}
-	}
-	std::cerr << "data chunk not found\n";
-	return false;
-}
-
-struct Word {
-	double start;
-	double end;
-	double prob;
-	std::string text;
-};
-
-} // namespace
-
-int main(int argc, char** argv) {
-	if (argc < 3) {
-		std::cerr << "Usage: wcpp_dtw_bench <model.bin> <audio-16k-mono.wav> [--lang en]\n";
-		return 2;
-	}
-	const std::string model_path = argv[1];
-	const std::string wav_path   = argv[2];
-	std::string lang = "en";
-	for (int i = 3; i + 1 < argc; ++i) {
-		if (std::string(argv[i]) == "--lang") lang = argv[i + 1];
-	}
-
-	std::vector<float> pcm;
-	int sample_rate = 0;
-	int channels    = 0;
-	if (!read_wav_pcm16(wav_path, pcm, sample_rate, channels)) return 3;
-	if (sample_rate != 16000 || channels != 1) {
-		std::cerr << "fixture must be 16 kHz mono, got " << sample_rate << "Hz " << channels << "ch\n";
-		return 3;
-	}
-
-	// ---------- §4.1: init context with DTW + alignment heads preset ----------
-	whisper_context_params cparams = whisper_context_default_params();
-	cparams.use_gpu    = true;   // GPU offload via whatever backend this build links against
-	cparams.flash_attn = false;  // CRITICAL: DTW is incompatible with flash attention in v1.9.1 — the model logger literally disables dtw_token_timestamps itself if flash_attn=1, breaking the §4.1 guardrail.
-	cparams.dtw_token_timestamps = true;
-	cparams.dtw_aheads_preset    = WHISPER_AHEADS_SMALL;
-
-	whisper_context* ctx = whisper_init_from_file_with_params(model_path.c_str(), cparams);
-	if (!ctx) {
-		std::cerr << "whisper_init_from_file_with_params failed for " << model_path << "\n";
-		return 4;
-	}
-
-	whisper_full_params wparams = whisper_full_default_params(WHISPER_SAMPLING_GREEDY);
-	wparams.token_timestamps = true;
-	wparams.language         = lang.c_str();
-	wparams.print_progress   = false;
-	wparams.print_realtime   = false;
-	wparams.print_timestamps = false;
-	wparams.n_threads        = static_cast<int>(std::thread::hardware_concurrency());
-
-	const auto t0 = std::chrono::steady_clock::now();
-	const int rc  = whisper_full(ctx, wparams, pcm.data(), static_cast<int>(pcm.size()));
-	const auto t1 = std::chrono::steady_clock::now();
-	if (rc != 0) {
-		std::cerr << "whisper_full returned " << rc << "\n";
-		whisper_free(ctx);
-		return 5;
-	}
-	const double elapsed_s = std::chrono::duration<double>(t1 - t0).count();
-	const double audio_s   = pcm.size() / 16000.0;
-	const double rtf       = audio_s > 0 ? elapsed_s / audio_s : 0.0;
-
-	const int n_vocab = whisper_n_vocab(ctx);
-	const whisper_token eot = whisper_token_eot(ctx);
-	std::vector<std::string> vocab_strs(n_vocab);
-	for (int i = 0; i < n_vocab; ++i) vocab_strs[i] = whisper_token_to_str(ctx, i);
-
-	// ---------- Single walk: build segments + word groups + §4.1 guardrail ----------
-	bool   dtw_guard_pass      = true;
-	std::string guardrail_msg;
-	int64_t dtw_abs_delta_sum  = 0;
-	int64_t prev_t_dtw         = 0;
-	int    non_special_tokens  = 0;
-
-	struct Segment {
-		double start, end;
-		std::string text;
-		std::vector<Word> words;
-	};
-	std::vector<Segment> segments;
-
-	const int n_segments = whisper_full_n_segments(ctx);
-	for (int si = 0; si < n_segments; ++si) {
-		Segment seg;
-		seg.start = whisper_full_get_segment_t0(ctx, si) / 100.0;
-		seg.end   = whisper_full_get_segment_t1(ctx, si) / 100.0;
-		// Use whisper.cpp's segment text — that string already strips
-		// _BEG_ / [_TT_NNN] markers (whisper_full handles them).
-		const char* seg_text_c = whisper_full_get_segment_text(ctx, si);
-		if (seg_text_c) seg.text = seg_text_c;
-
-		// First pass: collect (t_dtw of first token, raw text, prob mean) per
-		// word group, walking the token stream.
-		struct W { double t_dtw_first; double p_sum; int p_n; std::string text; bool real; };
-		std::vector<W> word_buf;
-		std::string cur_text;
-		bool in_word = false;
-		double w_first_t_dtw = 0;
-		double w_p_sum = 0; int w_p_n = 0;
-
-		const int n_tokens = whisper_full_n_tokens(ctx, si);
-		for (int ti = 0; ti < n_tokens; ++ti) {
-			const whisper_token_data td = whisper_full_get_token_data(ctx, si, ti);
-			std::string raw = (td.id >= 0 && td.id < n_vocab) ? vocab_strs[td.id] : std::string();
-
-			if (td.id >= eot) continue; // special token: skip text AND words
-
-			// §4.1 guardrail — track t_dtw vs t0 + monotonicity.
-			if (td.t_dtw == -1) {
-				dtw_guard_pass = false;
-				if (guardrail_msg.empty()) guardrail_msg = "token t_dtw == -1 (DTW not computed)";
-			}
-			const int64_t delta = std::abs(td.t_dtw - td.t0);
-			dtw_abs_delta_sum += delta;
-			if (non_special_tokens > 0 && td.t_dtw < prev_t_dtw) {
-				dtw_guard_pass = false;
-				if (guardrail_msg.empty()) guardrail_msg = "non-monotonic t_dtw";
-			}
-			prev_t_dtw = td.t_dtw;
-			++non_special_tokens;
-
-			const bool starts_word = (!in_word) || (!raw.empty() && raw[0] == ' ');
-			const double td_dtw = (td.t_dtw >= 0 ? td.t_dtw : 0) / 100.0;
-
-			if (starts_word && in_word) {
-				word_buf.push_back({ w_first_t_dtw, w_p_sum, w_p_n, cur_text, true });
-				w_p_sum = 0; w_p_n = 0; cur_text.clear();
-			}
-			if (starts_word) {
-				in_word = true;
-				w_first_t_dtw = td_dtw;
-				cur_text = (!raw.empty() && raw[0] == ' ') ? raw.substr(1) : raw;
-			} else {
-				cur_text += raw;
-			}
-			w_p_sum += td.p;
-			w_p_n   += 1;
-		}
-		if (in_word) {
-			word_buf.push_back({ w_first_t_dtw, w_p_sum, w_p_n, cur_text, true });
-		}
-
-		// Second pass: assign per-word start/end.
-		//   word.start = its own t_dtw (the moment the model started emitting it)
-		//   word.end   = the next word's t_dtw (the moment this word finished)
-		//                or, for the last word in the segment, the segment's t1
-		// — so single-token words get a real audio range, not a zero-width point.
-		for (size_t wi = 0; wi < word_buf.size(); ++wi) {
-			Word w;
-			w.start = word_buf[wi].t_dtw_first;
-			w.end   = (wi + 1 < word_buf.size())
-			            ? word_buf[wi + 1].t_dtw_first
-			            : seg.end;
-			w.prob  = word_buf[wi].p_sum / std::max(1, word_buf[wi].p_n);
-			w.text  = word_buf[wi].text;
-			seg.words.push_back(w);
-		}
-
-		segments.push_back(std::move(seg));
-	}
-
-	// §4.1 final check: zero abs-delta sum means DTW identical to heuristic.
-	if (non_special_tokens > 0 && dtw_abs_delta_sum == 0) {
-		dtw_guard_pass = false;
-		if (guardrail_msg.empty()) guardrail_msg = "Σ|t_dtw − t0| == 0 (DTW identical to heuristic)";
-	}
-
-	std::fprintf(stderr,
-		"wcpp_dtw_bench[§4.1 guardrail]: %s (non_special_tokens=%d, Σ|t_dtw-t0|=%lld) => %s\n",
-		dtw_guard_pass ? "PASS" : "FAIL",
-		non_special_tokens,
-		static_cast<long long>(dtw_abs_delta_sum),
-		guardrail_msg.empty() ? "ok" : guardrail_msg.c_str());
-	if (!dtw_guard_pass) {
-		whisper_free(ctx);
-		return 6;
-	}
-
-	// ---------- Emit JSON ----------
-	std::string whole_text;
-	for (const auto& s : segments) whole_text += s.text;
-
-	std::cout.setf(std::ios::fixed);
-	std::cout.precision(6);
-	std::cout << "{\n";
-	std::cout << "  \"backend\": \"" << WCPP_BACKEND << "\",\n";
-	std::cout << "  \"detected_language\": \"" << json_escape(lang) << "\",\n";
-	std::cout << "  \"language\": \"" << json_escape(lang) << "\",\n";
-	std::cout << "  \"timing\": { \"elapsed_s\": " << elapsed_s
-	          << ", \"audio_s\": " << audio_s
-	          << ", \"rtf\": " << rtf << " },\n";
-	std::cout << "  \"text\": \"" << json_escape(whole_text) << "\",\n";
-	std::cout << "  \"segments\": [";
-	for (size_t si = 0; si < segments.size(); ++si) {
-		const auto& s = segments[si];
-		std::cout << (si ? ",\n    {" : "\n    {");
-		std::cout << "\"id\":" << si
-		          << ",\"start\":" << s.start
-		          << ",\"end\":"   << s.end
-		          << ",\"text\":\"" << json_escape(s.text) << "\",\"words\":[";
-		for (size_t wi = 0; wi < s.words.size(); ++wi) {
-			const auto& w = s.words[wi];
-			std::cout << (wi ? "," : "");
-			std::cout << "{\"word\":\"" << json_escape(w.text)
-			          << "\",\"start\":" << w.start
-			          << ",\"end\":"     << w.end
-			          << ",\"probability\":" << w.prob << "}";
-		}
-		std::cout << "]}";
-	}
-	std::cout << "\n  ]\n}\n";
-
-	whisper_free(ctx);
-	return 0;
-}
diff --git a/tools/stt-eval/whispercpp-dtw-poc/harness/wer.mjs b/tools/stt-eval/whispercpp-dtw-poc/harness/wer.mjs
deleted file mode 100644
index b27f48de59..0000000000
--- a/tools/stt-eval/whispercpp-dtw-poc/harness/wer.mjs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Word-level WER (Levenshtein) between reference and hypothesis text.
-function normalize(s) {
-	return s
-		.toUpperCase()
-		.replace(/[.,!?;:"“”‘’]/g, "")
-		.replace(/-/g, " ")
-		.split(/\s+/)
-		.filter(Boolean);
-}
-
-function wer(ref, hyp) {
-	const r = normalize(ref);
-	const h = normalize(hyp);
-	const n = r.length,
-		m = h.length;
-	const d = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
-	for (let i = 0; i <= n; i++) d[i][0] = i;
-	for (let j = 0; j <= m; j++) d[0][j] = j;
-	for (let i = 1; i <= n; i++) {
-		for (let j = 1; j <= m; j++) {
-			if (r[i - 1] === h[j - 1]) d[i][j] = d[i - 1][j - 1];
-			else d[i][j] = 1 + Math.min(d[i - 1][j - 1], d[i - 1][j], d[i][j - 1]);
-		}
-	}
-	const edits = d[n][m];
-	return { edits, refWords: n, wer: n === 0 ? 0 : edits / n };
-}
-
-const [, , refPath, hypText] = process.argv;
-const fs = await import("fs");
-const ref = fs.readFileSync(refPath, "utf8").trim();
-const result = wer(ref, hypText);
-console.log(JSON.stringify(result));
diff --git a/website/package.json b/website/package.json
index 430f2cd622..41f29f2414 100644
--- a/website/package.json
+++ b/website/package.json
@@ -14,7 +14,6 @@
 		"@docusaurus/core": "^3.9.2",
 		"@docusaurus/preset-classic": "^3.9.2",
 		"@mdx-js/react": "^3.1.0",
-		"clsx": "^2.1.1",
 		"lucide-react": "^1.23.0",
 		"prism-react-renderer": "^2.4.1",
 		"react": "^18.3.1",