diff --git a/home/.managed/git/delta-config b/home/.managed/git/delta-config
new file mode 100644
index 0000000..8909254
--- /dev/null
+++ b/home/.managed/git/delta-config
@@ -0,0 +1,57 @@
+# Delta Configuration - Dracula Theme
+[delta]
+    # Core Settings
+    navigate = true                      # n/N to jump between files
+    side-by-side = false                 # Unified diff (better for small changes)
+    line-numbers = true                  # Show line numbers
+    syntax-theme = Dracula               # Match Dracula theme
+    paging = never                       # Let lazygit handle paging
+
+    # Display Quality
+    true-color = always
+    hyperlinks = true
+    hyperlinks-file-link-format = "file://{path}"
+
+    # Line Number Styling (clearer format)
+    line-numbers-left-format = "{nm:>4} ⋮"   # Old file line
+    line-numbers-right-format = "{np:>4} │"  # New file line
+    line-numbers-left-style = "#6272a4"      # Dracula comment
+    line-numbers-right-style = "#6272a4"
+    line-numbers-minus-style = "#ff5555"     # Red for removed
+    line-numbers-plus-style = "#50fa7b"      # Green for added
+    line-numbers-zero-style = "#6272a4"      # Comment for unchanged
+
+    # Hunk Headers (the @@ lines)
+    hunk-header-style = file line-number syntax
+    hunk-header-decoration-style = "#bd93f9" box  # Purple box
+    hunk-header-line-number-style = "#f1fa8c"     # Yellow line numbers
+
+    # File Headers
+    file-style = "#ff79c6" bold            # Pink filename
+    file-decoration-style = "#ff79c6" ul   # Underline
+
+    # Diff Styling (subtle backgrounds)
+    minus-style = syntax "#3f2d3d"                    # Subtle red bg for deletions
+    minus-emph-style = syntax "#5f3746"               # Stronger red for changed parts
+    minus-non-emph-style = syntax auto
+    plus-style = syntax "#273a2e"                     # Subtle green bg for additions
+    plus-emph-style = syntax "#2f4f39"                # Stronger green for changed parts
+    plus-non-emph-style = syntax auto
+
+    # Whitespace Handling
+    whitespace-error-style = "#ff5555" reverse        # Highlight trailing whitespace
+
+    # Merge Conflict Styling
+    merge-conflict-begin-symbol = "⌃"
+    merge-conflict-end-symbol = "⌄"
+    merge-conflict-ours-diff-header-style = "#f1fa8c" bold
+    merge-conflict-theirs-diff-header-style = "#f1fa8c" bold italic
+
+[interactive]
+    diffFilter = delta --color-only --features=interactive
+
+[delta "interactive"]
+    keep-plus-minus-markers = false
+
+[diff]
+    colorMoved = default
diff --git a/home/.managed/lazygit/config.yml b/home/.managed/lazygit/config.yml
index 5fafe09..be8a90a 100755
--- a/home/.managed/lazygit/config.yml
+++ b/home/.managed/lazygit/config.yml
@@ -1,23 +1,137 @@
-gui:
-  theme:
-    activeBorderColor:
-      - "#E97387"
-      - bold
-    inactiveBorderColor:
-      - "#a5adce"
-    optionsTextColor:
-      - "#8caaee"
-    selectedLineBgColor:
-      - "#ECCFD3"
-    cherryPickedCommitBgColor:
-      - "#51576d"
-    cherryPickedCommitFgColor:
-      - "#CFF2E2"
-    unstagedChangesColor:
-      - "#E97387"
-    defaultFgColor:
-      - "#6B6B6B"
-    searchingActiveBorderColor:
-      - "#e5c890"
-    authorColors:
-      "*": "#babbf1"
+gui:
+  # Dracula Theme - Official Colors
+  theme:
+    activeBorderColor:
+      - "#ff79c6" # Pink
+      - bold
+    inactiveBorderColor:
+      - "#6272a4" # Comment
+    searchingActiveBorderColor:
+      - "#8be9fd" # Cyan
+      - bold
+    optionsTextColor:
+      - "#bd93f9" # Purple
+    selectedLineBgColor:
+      - "#44475a" # Current Line
+    inactiveViewSelectedLineBgColor:
+      - bold
+    cherryPickedCommitFgColor:
+      - "#8be9fd" # Cyan
+    cherryPickedCommitBgColor:
+      - "#44475a" # Current Line
+    markedBaseCommitFgColor:
+      - "#f1fa8c" # Yellow
+    markedBaseCommitBgColor:
+      - "#44475a" # Current Line
+    unstagedChangesColor:
+      - "#ff5555" # Red
+    defaultFgColor:
+      - "#f8f8f2" # Foreground
+    authorColors:
+      "*": "#bd93f9" # Unified purple for all authors
+  # Nerd Fonts
+  nerdFontsVersion: "3"
+  showFileIcons: true
+  # Visual Preferences
+  border: "rounded"
+  animateExplosion: true
+  # Info Density (Balanced)
+  showListFooter: true
+  showFileTree: true
+  showCommandLog: true
+  showBottomLine: true
+  showPanelJumps: true
+  commitHashLength: 8
+  showBranchCommitHash: false
+  showDivergenceFromBaseBranch: "arrowAndNumber"
+  # Disable Annoying Popups
+  skipDiscardChangeWarning: true
+  skipStashWarning: true
+  skipRewordInEditorWarning: true
+  showRandomTip: false
+  # Window Sizing
+  scrollHeight: 8
+  sidePanelWidth: 0.3333
+  expandFocusedSidePanel: false
+  # Commit Display
+  commitAuthorShortLength: 2
+  commitAuthorLongLength: 17
+git:
+  # Paging (use delta)
+  pagers:
+    - colorArg: always
+      pager: delta
+  # Auto-behaviors
+  autoFetch: true
+  autoRefresh: true
+  fetchAll: true
+  autoStageResolvedConflicts: true
+  # Commit Settings
+  commit:
+    signOff: false
+    autoWrapCommitMessage: true
+    autoWrapWidth: 72
+  # Log Display
+  log:
+    order: "topo-order"
+    showGraph: "always"
+    showWholeGraph: false
+  # Parsing
+  parseEmoji: true
+  # Copy Behavior
+  truncateCopiedCommitHashesTo: 12
+os:
+  edit: "micro {{filename}}"
+  editAtLine: "micro {{filename}}:{{line}}"
+  editAtLineAndWait: "micro {{filename}}:{{line}}"
+  editInTerminal: true
+update:
+  method: "never"
+confirmOnQuit: false
+quitOnTopLevelReturn: false
+disableStartupPopups: true
+promptToReturnFromSubprocess: false
+refresher:
+  refreshInterval: 2 # Fast refresh for file changes
+  fetchInterval: 60 # Fetch from remote every 60s
+customCommands:
+  - key: "a"
+    context: "commits"
+    description: "Show CI status for commit"
+    command: 'bash -c "gh run list --commit {{.SelectedCommit.Sha}} --json conclusion,status,name,updatedAt --jq ''if length == 0 then \"No CI runs found\" else .[] | \"\\(.name): \\(if .conclusion == \"success\" then \"✓\" elif .conclusion == \"failure\" then \"✗\" elif .status == \"in_progress\" then \"⏳\" else \"?\" end) \\(.conclusion // .status)\" end''"'
+    loadingText: "Checking CI status..."
+  - key: "A"
+    context: "commits"
+    description: "View CI logs for commit"
+    command: 'bash -c "RUN_ID=$(gh run list --commit {{.SelectedCommit.Sha}} --json databaseId -q ''.[0].databaseId''); if [ -n \"$RUN_ID\" ]; then gh run view $RUN_ID --log; else echo \"No CI runs found for this commit\"; fi"'
+    loadingText: "Loading CI logs..."
+  - key: "a"
+    context: "localBranches"
+    description: "Show CI status for branch"
+    command: 'bash -c "gh run list --branch {{.SelectedLocalBranch.Name}} -L 1 --json conclusion,status,name,updatedAt --jq ''if length == 0 then \"No CI runs for this branch\" else .[0] | \"Latest: \\(.name) - \\(if .conclusion == \"success\" then \"✓ Passed\" elif .conclusion == \"failure\" then \"✗ Failed\" elif .status == \"in_progress\" then \"⏳ Running\" else .status end) (\\(.updatedAt))\" end''"'
+    loadingText: "Checking CI status..."
+  - key: "A"
+    context: "localBranches"
+    description: "View latest CI run for branch"
+    command: 'bash -c "RUN_ID=$(gh run list --branch {{.SelectedLocalBranch.Name}} -L 1 --json databaseId -q ''.[0].databaseId''); if [ -n \"$RUN_ID\" ]; then gh run view $RUN_ID --log; else echo \"No CI runs found for this branch\"; fi"'
+    loadingText: "Loading CI logs..."
+  - key: "w"
+    context: "files"
+    description: "Commit staged changes without pre-commit hooks"
+    prompts:
+      - type: "input"
+        title: "Commit message"
+        key: "message"
+    command: 'git commit --no-verify -m "{{.Form.message}}"'
+  - key: "o"
+    context: "commits"
+    description: "Open commit in GitHub"
+    command: "gh browse {{.SelectedCommit.Sha}}"
+  - key: "o"
+    context: "files"
+    description: "Open file in GitHub"
+    command: "gh browse {{.SelectedFile.Name}}"
+  - key: "<c-r>"
+    context: "localBranches"
+    description: "Create PR for branch"
+    command: "gh pr create --fill --web"
diff --git a/home/dot_config/fontconfig/fonts.conf b/home/dot_config/fontconfig/fonts.conf
index 543b4b2..597dd09 100644
--- a/home/dot_config/fontconfig/fonts.conf
+++ b/home/dot_config/fontconfig/fonts.conf
@@ -11,10 +11,6 @@
 -->
 <fontconfig>
 
-  <!-- ============================================================
-       Global Rendering Settings
-       ============================================================ -->
-
   <!-- Enable antialiasing for smooth edges -->
   <match target="font">
     <edit name="antialias" mode="assign">
@@ -87,10 +83,6 @@
     </edit>
   </match>
 
-  <!-- ============================================================
-       Default Font Aliases
-       ============================================================ -->
-
   <!-- Sans-serif: Inter with Noto Sans fallback -->
   <alias>
     <family>sans-serif</family>
@@ -194,10 +186,6 @@
     </prefer>
   </alias>
 
-  <!-- ============================================================
-       Font-Specific Tweaks
-       ============================================================ -->
-
   <!--
     Geist Mono: Use slight hinting for clean rendering
     Geist Mono has good weight distribution
diff --git a/home/dot_gitconfig.tmpl b/home/dot_gitconfig.tmpl
index c262e10..db486b8 100644
--- a/home/dot_gitconfig.tmpl
+++ b/home/dot_gitconfig.tmpl
@@ -59,11 +59,9 @@
 	editor = micro
 	pager = delta
 
-[interactive]
-	diffFilter = delta --color-only
-
-[delta]
-	navigate = true  # use n and N to move between diff sections
+# Delta configuration
+[include]
+	path = {{ .chezmoi.sourceDir }}/.managed/git/delta-config
 
 [merge]
 	conflictStyle = zdiff3
diff --git a/home/dot_local/bin/executable_install-fonts.ts b/home/dot_local/bin/executable_install-fonts.ts
index f2f4112..d5a973b 100644
--- a/home/dot_local/bin/executable_install-fonts.ts
+++ b/home/dot_local/bin/executable_install-fonts.ts
@@ -18,10 +18,6 @@ import { join, basename } from "node:path";
 import { parseArgs } from "node:util";
 import { $ } from "bun";
 
-// ============================================================================
-// Types
-// ============================================================================
-
 interface GoogleFont {
   id: string;
   family: string;
@@ -65,13 +61,16 @@ interface FuseResult<T> {
   score?: number;
 }
 
-// ============================================================================
-// Constants
-// ============================================================================
-
 const FONTS_DIR = join(homedir(), ".local", "share", "fonts");
 // Meta-config location: chezmoi source dir, not deployed to filesystem
-const CONFIG_PATH = join(homedir(), ".local", "share", "chezmoi", "meta", "fonts.toml");
+const CONFIG_PATH = join(
+  homedir(),
+  ".local",
+  "share",
+  "chezmoi",
+  "meta",
+  "fonts.toml",
+);
 const API_BASE = "https://gwfh.mranftl.com/api";
 const CACHE_FILE = join(homedir(), ".cache", "font-catalog.json");
 const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
@@ -124,10 +123,6 @@ const CYAN = "\x1b[36m";
 const RESET = "\x1b[0m";
 const BOLD = "\x1b[1m";
 
-// ============================================================================
-// Logging
-// ============================================================================
-
 const log = {
   info: (msg: string) => console.log(`${BLUE}[info]${RESET} ${msg}`),
   success: (msg: string) => console.log(`${GREEN}[ok]${RESET} ${msg}`),
@@ -136,10 +131,6 @@ const log = {
   step: (msg: string) => console.log(`${CYAN}>>>${RESET} ${msg}`),
 };
 
-// ============================================================================
-// Simple Fuzzy Matching (no external deps)
-// ============================================================================
-
 function fuzzyScore(needle: string, haystack: string): number {
   const n = needle.toLowerCase();
   const h = haystack.toLowerCase();
@@ -181,7 +172,7 @@ function fuzzySearch<T>(
   query: string,
   getKey: (item: T) => string,
   threshold = 0.3,
-  limit = 5
+  limit = 5,
 ): FuseResult<T>[] {
   const results: FuseResult<T>[] = [];
 
@@ -197,13 +188,9 @@ function fuzzySearch<T>(
     .slice(0, limit);
 }
 
-// ============================================================================
-// API Functions
-// ============================================================================
-
 async function fetchWithRetry(
   url: string,
-  retries = 3
+  retries = 3,
 ): Promise<Response | null> {
   for (let i = 0; i < retries; i++) {
     try {
@@ -267,14 +254,7 @@ async function fetchFontDetails(fontId: string): Promise<FontDetails | null> {
   return response.json();
 }
 
-// ============================================================================
-// Font Installation
-// ============================================================================
-
-async function downloadFont(
-  url: string,
-  destPath: string
-): Promise<boolean> {
+async function downloadFont(url: string, destPath: string): Promise<boolean> {
   try {
     const response = await fetchWithRetry(url);
     if (!response) return false;
@@ -288,10 +268,6 @@ async function downloadFont(
   }
 }
 
-// ============================================================================
-// GitHub Font Installation (Iosevka, etc.)
-// ============================================================================
-
 interface GitHubRelease {
   tag_name: string;
   assets: Array<{
@@ -330,7 +306,9 @@ async function installGitHubFont(fontName: string): Promise<boolean> {
 
   if (!asset) {
     log.error(`No matching asset found for ${fontName} in ${release.tag_name}`);
-    log.info(`Available assets: ${release.assets.map((a) => a.name).join(", ")}`);
+    log.info(
+      `Available assets: ${release.assets.map((a) => a.name).join(", ")}`,
+    );
     return false;
   }
 
@@ -364,7 +342,9 @@ async function installGitHubFont(fontName: string): Promise<boolean> {
   rmSync(zipPath, { force: true });
 
   const files = readdirSync(fontDir).filter((f) => f.endsWith(".ttf"));
-  log.success(`Installed ${fontName}: ${files.length} files (${release.tag_name})`);
+  log.success(
+    `Installed ${fontName}: ${files.length} files (${release.tag_name})`,
+  );
 
   return true;
 }
@@ -398,7 +378,7 @@ function weightToName(weight: number): string {
 
 async function installFont(
   fontName: string,
-  catalog: GoogleFont[]
+  catalog: GoogleFont[],
 ): Promise<boolean> {
   // Fuzzy search for the font
   const results = fuzzySearch(catalog, fontName, (f) => f.family, 0.3, 5);
@@ -413,7 +393,7 @@ async function installFont(
       fontName,
       (name) => name,
       0.3,
-      3
+      3,
     );
     if (githubMatches.length > 0) {
       const suggestions = githubMatches.map((r) => r.item).join(", ");
@@ -427,7 +407,7 @@ async function installFont(
       fontName,
       (f) => f.family,
       0.2,
-      5
+      5,
     );
     if (looseSuggestions.length > 0) {
       const suggestions = looseSuggestions.map((r) => r.item.family).join(", ");
@@ -442,7 +422,7 @@ async function installFont(
   // Warn if not an exact match
   if (font.family.toLowerCase() !== fontName.toLowerCase()) {
     log.warn(
-      `"${fontName}" matched to "${font.family}" (score: ${(bestMatch.score ?? 0).toFixed(2)})`
+      `"${fontName}" matched to "${font.family}" (score: ${(bestMatch.score ?? 0).toFixed(2)})`,
     );
   }
 
@@ -500,7 +480,7 @@ async function installFont(
   if (successCount > 0) {
     log.success(
       `Installed ${font.family}: ${successCount} files` +
-        (failCount > 0 ? ` (${failCount} failed)` : "")
+        (failCount > 0 ? ` (${failCount} failed)` : ""),
     );
     return true;
   } else {
@@ -513,10 +493,6 @@ async function installFont(
   }
 }
 
-// ============================================================================
-// Configuration
-// ============================================================================
-
 async function loadConfig(): Promise<FontConfig> {
   if (!existsSync(CONFIG_PATH)) {
     throw new Error(`Config not found: ${CONFIG_PATH}`);
@@ -572,10 +548,6 @@ async function loadConfig(): Promise<FontConfig> {
   return config;
 }
 
-// ============================================================================
-// Main Commands
-// ============================================================================
-
 async function listFonts(): Promise<void> {
   const catalog = await fetchFontCatalog();
 
@@ -612,7 +584,7 @@ async function searchFonts(query: string): Promise<void> {
     query,
     (name) => name,
     0.2,
-    10
+    10,
   );
 
   if (results.length === 0 && githubResults.length === 0) {
@@ -627,7 +599,7 @@ async function searchFonts(query: string): Promise<void> {
     const fontName = result.item;
     const score = ((result.score ?? 0) * 100).toFixed(0);
     console.log(
-      `  ${GREEN}${fontName}${RESET} (monospace) - via GitHub [${score}% match]`
+      `  ${GREEN}${fontName}${RESET} (monospace) - via GitHub [${score}% match]`,
     );
   }
 
@@ -637,7 +609,7 @@ async function searchFonts(query: string): Promise<void> {
     const score = ((result.score ?? 0) * 100).toFixed(0);
     const variants = Array.isArray(font.variants) ? font.variants.length : "?";
     console.log(
-      `  ${GREEN}${font.family}${RESET} (${font.category}) - ${variants} variants [${score}% match]`
+      `  ${GREEN}${font.family}${RESET} (${font.category}) - ${variants} variants [${score}% match]`,
     );
   }
   console.log();
@@ -711,10 +683,6 @@ async function installFromConfig(): Promise<void> {
   }
 }
 
-// ============================================================================
-// Entry Point
-// ============================================================================
-
 async function main(): Promise<void> {
   const { values, positionals } = parseArgs({
     args: Bun.argv.slice(2),
diff --git a/home/dot_local/bin/executable_share.ts b/home/dot_local/bin/executable_share.ts
index 4909430..15aba27 100755
--- a/home/dot_local/bin/executable_share.ts
+++ b/home/dot_local/bin/executable_share.ts
@@ -16,16 +16,16 @@
  *   R2_BUCKET                Bucket name
  */
 
-import { existsSync, fstatSync } from 'fs';
-import { tmpdir, platform } from 'os';
-import { join, basename, extname } from 'path';
-import { parseArgs } from 'util';
-import chalk from 'chalk';
-import { S3Client } from '@aws-sdk/client-s3';
-import { Upload } from '@aws-sdk/lib-storage';
-import { nanoid } from 'nanoid';
-import { fileTypeFromBuffer } from 'file-type';
-import { $ } from 'bun';
+import { existsSync, fstatSync } from "fs";
+import { tmpdir, platform } from "os";
+import { join, basename, extname } from "path";
+import { parseArgs } from "util";
+import chalk from "chalk";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import { nanoid } from "nanoid";
+import { fileTypeFromBuffer } from "file-type";
+import { $ } from "bun";
 
 interface UploadSource {
   buffer: Buffer;
@@ -39,12 +39,12 @@ interface UploadResult {
   size: number;
 }
 
-type FixMode = 'never' | 'prompt' | 'always';
+type FixMode = "never" | "prompt" | "always";
 
 interface MediaIssue {
   id: string;
   description: string;
-  severity: 'error' | 'warning';
+  severity: "error" | "warning";
   autoFix: boolean; // true = instant/lossless, false = slow/lossy
   fix: (buffer: Buffer) => Promise<Buffer>;
 }
@@ -63,14 +63,19 @@ interface VideoProbe {
 type TimeoutHandle = ReturnType<typeof setTimeout>;
 type IntervalHandle = ReturnType<typeof setInterval>;
 
-const DOMAIN = 'https://i.xevion.dev';
+const DOMAIN = "https://i.xevion.dev";
 
-const REQUIRED_ENV = ['R2_ENDPOINT', 'R2_ACCESS_KEY_ID', 'R2_SECRET_ACCESS_KEY', 'R2_BUCKET'];
+const REQUIRED_ENV = [
+  "R2_ENDPOINT",
+  "R2_ACCESS_KEY_ID",
+  "R2_SECRET_ACCESS_KEY",
+  "R2_BUCKET",
+];
 const ENV = {
-  endpoint: process.env.R2_ENDPOINT || '',
-  accessKeyId: process.env.R2_ACCESS_KEY_ID || '',
-  secretAccessKey: process.env.R2_SECRET_ACCESS_KEY || '',
-  bucket: process.env.R2_BUCKET || '',
+  endpoint: process.env.R2_ENDPOINT || "",
+  accessKeyId: process.env.R2_ACCESS_KEY_ID || "",
+  secretAccessKey: process.env.R2_SECRET_ACCESS_KEY || "",
+  bucket: process.env.R2_BUCKET || "",
 };
 
 const TIMING = {
@@ -86,90 +91,90 @@ const SIZE_THRESHOLDS = {
   reencodeAuto: 10 * 1024 * 1024, // Auto re-encode incompatible codecs below this size
 };
 
-const INCOMPATIBLE_VIDEO_CODECS = ['hevc', 'h265', 'av1'];
+const INCOMPATIBLE_VIDEO_CODECS = ["hevc", "h265", "av1"];
 
 const COLORS = {
-  spinner: ['#A5D8DD', '#9DCCB4', '#B8D99A', '#E8D4A2', '#F4B8A4', '#F5A6A6'],
-  success: '#9DCCB4',
-  error: '#E89999',
-  label: '#6B7280',
-  dim: '#9CA3AF',
-  progressFilled: '#A5D8DD',
-  progressEmpty: '#374151',
+  spinner: ["#A5D8DD", "#9DCCB4", "#B8D99A", "#E8D4A2", "#F4B8A4", "#F5A6A6"],
+  success: "#9DCCB4",
+  error: "#E89999",
+  label: "#6B7280",
+  dim: "#9CA3AF",
+  progressFilled: "#A5D8DD",
+  progressEmpty: "#374151",
 };
 
 const MIME_EXTENSIONS: Record<string, string> = {
-  'image/png': 'png',
-  'image/jpeg': 'jpg',
-  'image/jpg': 'jpg',
-  'image/gif': 'gif',
-  'image/webp': 'webp',
-  'image/bmp': 'bmp',
-  'image/tiff': 'tiff',
-  'image/heic': 'heic',
-  'image/heif': 'heif',
-  'image/avif': 'avif',
-  'video/mp4': 'mp4',
-  'video/webm': 'webm',
-  'video/quicktime': 'mov',
-  'video/x-matroska': 'mkv',
-  'text/plain': 'txt',
-  'application/json': 'json',
-  'application/pdf': 'pdf',
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/bmp": "bmp",
+  "image/tiff": "tiff",
+  "image/heic": "heic",
+  "image/heif": "heif",
+  "image/avif": "avif",
+  "video/mp4": "mp4",
+  "video/webm": "webm",
+  "video/quicktime": "mov",
+  "video/x-matroska": "mkv",
+  "text/plain": "txt",
+  "application/json": "json",
+  "application/pdf": "pdf",
 };
 
 const EXTENSION_MIMES: Record<string, string> = {
-  'png': 'image/png',
-  'jpg': 'image/jpeg',
-  'jpeg': 'image/jpeg',
-  'gif': 'image/gif',
-  'webp': 'image/webp',
-  'bmp': 'image/bmp',
-  'tiff': 'image/tiff',
-  'heic': 'image/heic',
-  'heif': 'image/heif',
-  'avif': 'image/avif',
-  'mp4': 'video/mp4',
-  'webm': 'video/webm',
-  'mov': 'video/quicktime',
-  'mkv': 'video/x-matroska',
-  'txt': 'text/plain',
-  'json': 'application/json',
-  'pdf': 'application/pdf',
-  'js': 'application/javascript',
-  'ts': 'application/typescript',
-  'rs': 'text/x-rust',
-  'py': 'text/x-python',
-  'md': 'text/markdown',
-  'html': 'text/html',
-  'css': 'text/css',
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  tiff: "image/tiff",
+  heic: "image/heic",
+  heif: "image/heif",
+  avif: "image/avif",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  mkv: "video/x-matroska",
+  txt: "text/plain",
+  json: "application/json",
+  pdf: "application/pdf",
+  js: "application/javascript",
+  ts: "application/typescript",
+  rs: "text/x-rust",
+  py: "text/x-python",
+  md: "text/markdown",
+  html: "text/html",
+  css: "text/css",
 };
 
-const TRUTHY = ['y', 'yes', 'true', 't', 'Y', 'YES', 'TRUE', 'T'];
-const FALSY = ['n', 'no', 'false', 'f', 'N', 'NO', 'FALSE', 'F', 'deny'];
+const TRUTHY = ["y", "yes", "true", "t", "Y", "YES", "TRUE", "T"];
+const FALSY = ["n", "no", "false", "f", "N", "NO", "FALSE", "F", "deny"];
 
 let VERBOSE = false;
 let usedStdin = false;
 
 const IS_WSL = await (async () => {
   try {
-    const text = await Bun.file('/proc/version').text();
-    return text.toLowerCase().includes('microsoft');
+    const text = await Bun.file("/proc/version").text();
+    return text.toLowerCase().includes("microsoft");
   } catch {
     return false;
   }
 })();
 
-const IS_WINDOWS = platform() === 'win32';
+const IS_WINDOWS = platform() === "win32";
 
 class Spinner {
-  private frames = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
+  private frames = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
   private colors = COLORS.spinner;
   private index = 0;
   private interval: IntervalHandle | null = null;
 
   start(message: string) {
-    process.stdout.write('\x1B[?25l');
+    process.stdout.write("\x1B[?25l");
 
     this.interval = setInterval(() => {
       const colorIndex = this.index % this.colors.length;
@@ -183,28 +188,28 @@ class Spinner {
     if (this.interval) {
       clearInterval(this.interval);
       if (clearLine) {
-        process.stdout.write('\r\x1B[K');
+        process.stdout.write("\r\x1B[K");
       }
-      process.stdout.write('\x1B[?25h');
+      process.stdout.write("\x1B[?25h");
     }
   }
 }
 
 function restoreCursor() {
-  process.stdout.write('\x1B[?25h');
+  process.stdout.write("\x1B[?25h");
 }
 
-process.on('SIGINT', () => {
+process.on("SIGINT", () => {
   restoreCursor();
   process.exit(130);
 });
 
-process.on('SIGTERM', () => {
+process.on("SIGTERM", () => {
   restoreCursor();
   process.exit(143);
 });
 
-process.on('uncaughtException', (err) => {
+process.on("uncaughtException", (err) => {
   restoreCursor();
   console.error(err);
   process.exit(1);
@@ -224,8 +229,8 @@ class ProgressBar {
     const empty = this.barWidth - filled;
 
     const bar =
-      chalk.hex(COLORS.progressFilled)('█'.repeat(filled)) +
-      chalk.hex(COLORS.progressEmpty)('░'.repeat(empty));
+      chalk.hex(COLORS.progressFilled)("█".repeat(filled)) +
+      chalk.hex(COLORS.progressEmpty)("░".repeat(empty));
 
     const stats = `${formatBytes(loaded)}/${formatBytes(this.total)}`;
 
@@ -233,82 +238,90 @@ class ProgressBar {
   }
 
   finish() {
-    process.stdout.write('\r\x1B[K');
+    process.stdout.write("\r\x1B[K");
   }
 }
 
 function formatBytes(bytes: number): string {
-  if (bytes === 0) return '0 B';
+  if (bytes === 0) return "0 B";
   const k = 1024;
-  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const sizes = ["B", "KB", "MB", "GB"];
   const i = Math.floor(Math.log(bytes) / Math.log(k));
   return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
 }
 
-function log(message: string, type: 'success' | 'error' | 'info' | 'dim' = 'info') {
+function log(
+  message: string,
+  type: "success" | "error" | "info" | "dim" = "info",
+) {
   const icons = {
-    success: chalk.hex(COLORS.success)('✓'),
-    error: chalk.hex(COLORS.error)('✗'),
-    info: chalk.hex(COLORS.dim)('→'),
-    dim: chalk.hex(COLORS.dim)('·'),
+    success: chalk.hex(COLORS.success)("✓"),
+    error: chalk.hex(COLORS.error)("✗"),
+    info: chalk.hex(COLORS.dim)("→"),
+    dim: chalk.hex(COLORS.dim)("·"),
   };
   console.log(`${icons[type]} ${message}`);
 }
 
 function debug(message: string, data?: unknown) {
   if (!VERBOSE) return;
-  console.error(chalk.hex(COLORS.label)('[debug]'), message);
+  console.error(chalk.hex(COLORS.label)("[debug]"), message);
   if (data !== undefined) {
     console.error(chalk.hex(COLORS.dim)(JSON.stringify(data, null, 2)));
   }
 }
 
-async function detectMimeType(buffer: Buffer, filename?: string): Promise<string> {
+async function detectMimeType(
+  buffer: Buffer,
+  filename?: string,
+): Promise<string> {
   const result = await fileTypeFromBuffer(buffer);
   if (result) {
-    debug('Detected MIME via file-type', { mime: result.mime });
+    debug("Detected MIME via file-type", { mime: result.mime });
     return result.mime;
   }
 
   if (filename) {
     const ext = extname(filename).slice(1).toLowerCase();
     if (EXTENSION_MIMES[ext]) {
-      debug('Detected MIME via extension', { ext, mime: EXTENSION_MIMES[ext] });
+      debug("Detected MIME via extension", { ext, mime: EXTENSION_MIMES[ext] });
       return EXTENSION_MIMES[ext];
     }
   }
 
-  debug('Defaulting to application/octet-stream');
-  return 'application/octet-stream';
+  debug("Defaulting to application/octet-stream");
+  return "application/octet-stream";
 }
 
 function getExtensionForMime(mime: string): string {
-  return MIME_EXTENSIONS[mime] || 'bin';
+  return MIME_EXTENSIONS[mime] || "bin";
 }
 
 function getMimeForExtension(ext: string): string {
-  const normalized = ext.replace(/^\.+/, '');
-  return EXTENSION_MIMES[normalized] || 'application/octet-stream';
+  const normalized = ext.replace(/^\.+/, "");
+  return EXTENSION_MIMES[normalized] || "application/octet-stream";
 }
 
 function isTextMime(mime: string): boolean {
-  return mime.startsWith('text/') ||
-    mime === 'application/json' ||
-    mime === 'application/javascript' ||
-    mime === 'application/typescript';
+  return (
+    mime.startsWith("text/") ||
+    mime === "application/json" ||
+    mime === "application/javascript" ||
+    mime === "application/typescript"
+  );
 }
 
 function isImageMime(mime: string): boolean {
-  return mime.startsWith('image/');
+  return mime.startsWith("image/");
 }
 
 function isVideoMime(mime: string): boolean {
-  return mime.startsWith('video/');
+  return mime.startsWith("video/");
 }
 
 async function readFromFile(path: string): Promise<UploadSource> {
   const spinner = new Spinner();
-  spinner.start('Reading file...');
+  spinner.start("Reading file...");
 
   try {
     if (!existsSync(path)) {
@@ -320,7 +333,7 @@ async function readFromFile(path: string): Promise<UploadSource> {
     const mimeType = await detectMimeType(buffer, filename);
 
     spinner.stop();
-    debug('Read file', { path, size: buffer.length, mimeType });
+    debug("Read file", { path, size: buffer.length, mimeType });
 
     return { buffer, filename, mimeType };
   } catch (e) {
@@ -338,7 +351,10 @@ function hasStdinData(): boolean {
     const stats = fstatSync(0);
     return stats.isFIFO() || stats.isSocket();
   } catch (error) {
-    debug('fstat stdin detection failed', error instanceof Error ? error.message : String(error));
+    debug(
+      "fstat stdin detection failed",
+      error instanceof Error ? error.message : String(error),
+    );
     return false;
   }
 }
@@ -346,7 +362,7 @@ function hasStdinData(): boolean {
 async function readFromStdin(): Promise<UploadSource> {
   usedStdin = true;
   const spinner = new Spinner();
-  spinner.start('Reading from stdin...');
+  spinner.start("Reading from stdin...");
 
   try {
     const chunks: Buffer[] = [];
@@ -358,12 +374,12 @@ async function readFromStdin(): Promise<UploadSource> {
     const buffer = Buffer.concat(chunks);
 
     if (buffer.length === 0) {
-      throw new Error('No data received from stdin');
+      throw new Error("No data received from stdin");
     }
 
     const mimeType = await detectMimeType(buffer);
     spinner.stop();
-    debug('Read stdin', { size: buffer.length, mimeType });
+    debug("Read stdin", { size: buffer.length, mimeType });
 
     return { buffer, mimeType };
   } catch (e) {
@@ -374,12 +390,14 @@ async function readFromStdin(): Promise<UploadSource> {
 
 async function copyToClipboard(text: string): Promise<void> {
   if (IS_WSL || IS_WINDOWS) {
-    const proc = Bun.spawn(['clip.exe'], { stdin: 'pipe' });
+    const proc = Bun.spawn(["clip.exe"], { stdin: "pipe" });
     proc.stdin.write(text);
     proc.stdin.end();
     await proc.exited;
   } else {
-    const proc = Bun.spawn(['xclip', '-selection', 'clipboard'], { stdin: 'pipe' });
+    const proc = Bun.spawn(["xclip", "-selection", "clipboard"], {
+      stdin: "pipe",
+    });
     proc.stdin.write(text);
     proc.stdin.end();
     await proc.exited;
@@ -388,88 +406,111 @@ async function copyToClipboard(text: string): Promise<void> {
 
 async function readFromClipboard(): Promise<UploadSource> {
   const spinner = new Spinner();
-  spinner.start('Reading clipboard...');
+  spinner.start("Reading clipboard...");
 
   try {
     if (IS_WSL || IS_WINDOWS) {
-      const result = await $`powershell.exe -NoProfile -Command "Get-Clipboard -Raw"`.text();
+      const result =
+        await $`powershell.exe -NoProfile -Command "Get-Clipboard -Raw"`.text();
       const text = result.trim();
 
       if (!text) {
-        throw new Error('Clipboard is empty');
+        throw new Error("Clipboard is empty");
       }
 
-      if (text.startsWith('/') && existsSync(text)) {
+      if (text.startsWith("/") && existsSync(text)) {
         spinner.stop();
-        const shouldUpload = await confirm(`Clipboard contains a file path: ${text}\nUpload this file?`);
+        const shouldUpload = await confirm(
+          `Clipboard contains a file path: ${text}\nUpload this file?`,
+        );
         if (shouldUpload) {
           return readFromFile(text);
         }
-        throw new Error('Upload cancelled');
+        throw new Error("Upload cancelled");
       }
 
       spinner.stop();
-      const buffer = Buffer.from(text, 'utf-8');
-      debug('Read clipboard text (WSL)', { size: buffer.length });
+      const buffer = Buffer.from(text, "utf-8");
+      debug("Read clipboard text (WSL)", { size: buffer.length });
 
-      return { buffer, mimeType: 'text/plain' };
+      return { buffer, mimeType: "text/plain" };
     }
 
     const targets = await $`xclip -selection clipboard -t TARGETS -o`.text();
-    const targetList = targets.trim().split('\n');
-    debug('Clipboard targets', targetList);
+    const targetList = targets.trim().split("\n");
+    debug("Clipboard targets", targetList);
 
-    if (targetList.includes('text/uri-list') || targetList.includes('x-special/gnome-copied-files')) {
-      const uris = await $`xclip -selection clipboard -t text/uri-list -o`.text();
-      const filePath = uris.split('\n')[0].replace(/^file:\/\//, '').trim();
+    if (
+      targetList.includes("text/uri-list") ||
+      targetList.includes("x-special/gnome-copied-files")
+    ) {
+      const uris =
+        await $`xclip -selection clipboard -t text/uri-list -o`.text();
+      const filePath = uris
+        .split("\n")[0]
+        .replace(/^file:\/\//, "")
+        .trim();
 
       if (filePath && existsSync(filePath)) {
         spinner.stop();
 
-        const shouldUpload = await confirm(`Clipboard contains a file path: ${filePath}\nUpload this file?`);
+        const shouldUpload = await confirm(
+          `Clipboard contains a file path: ${filePath}\nUpload this file?`,
+        );
         if (shouldUpload) {
           return readFromFile(filePath);
         } else {
-          throw new Error('Upload cancelled');
+          throw new Error("Upload cancelled");
         }
       }
     }
 
-    const imageTarget = targetList.find(t => t.startsWith('image/'));
+    const imageTarget = targetList.find((t) => t.startsWith("image/"));
     if (imageTarget) {
-      const isBmp = imageTarget === 'image/bmp';
-      const buffer = Buffer.from(await $`xclip -selection clipboard -t ${imageTarget} -o`.arrayBuffer());
+      const isBmp = imageTarget === "image/bmp";
+      const buffer = Buffer.from(
+        await $`xclip -selection clipboard -t ${imageTarget} -o`.arrayBuffer(),
+      );
 
       spinner.stop();
-      debug('Read clipboard image', { target: imageTarget, size: buffer.length });
+      debug("Read clipboard image", {
+        target: imageTarget,
+        size: buffer.length,
+      });
 
       if (isBmp) {
-        log('Converting BMP to PNG...', 'info');
-        return { buffer, mimeType: 'image/bmp', filename: 'paste.bmp' };
+        log("Converting BMP to PNG...", "info");
+        return { buffer, mimeType: "image/bmp", filename: "paste.bmp" };
       }
 
-      return { buffer, mimeType: imageTarget, filename: `paste.${getExtensionForMime(imageTarget)}` };
+      return {
+        buffer,
+        mimeType: imageTarget,
+        filename: `paste.${getExtensionForMime(imageTarget)}`,
+      };
     }
 
     const text = await $`xclip -selection clipboard -o`.text();
     if (!text.trim()) {
-      throw new Error('Clipboard is empty or contains unsupported data');
+      throw new Error("Clipboard is empty or contains unsupported data");
     }
 
     const trimmedText = text.trim();
-    if (trimmedText.startsWith('/') && existsSync(trimmedText)) {
+    if (trimmedText.startsWith("/") && existsSync(trimmedText)) {
       spinner.stop();
-      const shouldUpload = await confirm(`Clipboard contains a file path: ${trimmedText}\nUpload this file?`);
+      const shouldUpload = await confirm(
+        `Clipboard contains a file path: ${trimmedText}\nUpload this file?`,
+      );
       if (shouldUpload) {
         return readFromFile(trimmedText);
       }
     }
 
     spinner.stop();
-    const buffer = Buffer.from(text, 'utf-8');
-    debug('Read clipboard text', { size: buffer.length });
+    const buffer = Buffer.from(text, "utf-8");
+    debug("Read clipboard text", { size: buffer.length });
 
-    return { buffer, mimeType: 'text/plain' };
+    return { buffer, mimeType: "text/plain" };
   } catch (e) {
     spinner.stop();
     throw e;
@@ -477,11 +518,13 @@ async function readFromClipboard(): Promise<UploadSource> {
 }
 
 async function confirm(message: string): Promise<boolean> {
-  process.stdout.write(`${chalk.hex(COLORS.label)('?')} ${message} ${chalk.hex(COLORS.dim)('(y/n)')}: `);
+  process.stdout.write(
+    `${chalk.hex(COLORS.label)("?")} ${message} ${chalk.hex(COLORS.dim)("(y/n)")}: `,
+  );
 
   const input = await new Promise<string>((resolve) => {
     process.stdin.resume();
-    process.stdin.once('data', (data) => {
+    process.stdin.once("data", (data) => {
       process.stdin.pause();
       resolve(data.toString().trim());
     });
@@ -492,31 +535,36 @@ async function confirm(message: string): Promise<boolean> {
 
 async function promptExtension(): Promise<string | null> {
   while (true) {
-    process.stdout.write(`${chalk.hex(COLORS.label)('?')} File extension ${chalk.hex(COLORS.dim)('(default: .txt)')}: `);
+    process.stdout.write(
+      `${chalk.hex(COLORS.label)("?")} File extension ${chalk.hex(COLORS.dim)("(default: .txt)")}: `,
+    );
 
     const input = await new Promise<string>((resolve) => {
       process.stdin.resume();
-      process.stdin.once('data', (data) => {
+      process.stdin.once("data", (data) => {
         process.stdin.pause();
         resolve(data.toString().trim());
       });
     });
 
     if (!input) {
-      const useTxt = await confirm('Upload as .txt?');
-      if (useTxt) return 'txt';
+      const useTxt = await confirm("Upload as .txt?");
+      if (useTxt) return "txt";
       return null;
     }
 
-    if (!input.startsWith('.')) {
-      if (TRUTHY.includes(input)) return 'txt';
+    if (!input.startsWith(".")) {
+      if (TRUTHY.includes(input)) return "txt";
       if (FALSY.includes(input)) return null;
     }
 
-    let ext = input.startsWith('.') ? input.slice(1) : input;
+    let ext = input.startsWith(".") ? input.slice(1) : input;
 
-    if (ext.startsWith('.') || ext.includes('..')) {
-      log('Invalid extension format. Use format like "txt", ".txt", or ".ts.map"', 'error');
+    if (ext.startsWith(".") || ext.includes("..")) {
+      log(
+        'Invalid extension format. Use format like "txt", ".txt", or ".ts.map"',
+        "error",
+      );
       continue;
     }
 
@@ -529,15 +577,11 @@ async function cleanupTempFiles(...paths: string[]): Promise<void> {
     try {
       await $`rm -f ${path}`.quiet();
     } catch {
-      debug('Failed to cleanup temp file', path);
+      debug("Failed to cleanup temp file", path);
     }
   }
 }
 
-// ============================================================================
-// Media Validation
-// ============================================================================
-
 async function hasCommand(cmd: string): Promise<boolean> {
   try {
     await $`which ${cmd}`.quiet();
@@ -547,40 +591,45 @@ async function hasCommand(cmd: string): Promise<boolean> {
   }
 }
 
-async function writeTempFile(buffer: Buffer, ext = ''): Promise<string> {
+async function writeTempFile(buffer: Buffer, ext = ""): Promise<string> {
   const path = join(tmpdir(), `share-probe-${nanoid(8)}${ext}`);
   await Bun.write(path, buffer);
   return path;
 }
 
 function parseFixMode(value: string | undefined): FixMode {
-  if (!value) return 'prompt';
+  if (!value) return "prompt";
   const v = value.toLowerCase();
-  if (v.startsWith('n')) return 'never';
-  if (v.startsWith('a')) return 'always';
-  return 'prompt';
+  if (v.startsWith("n")) return "never";
+  if (v.startsWith("a")) return "always";
+  return "prompt";
 }
 
 function isAudioMime(mime: string): boolean {
-  return mime.startsWith('audio/');
+  return mime.startsWith("audio/");
 }
 
 async function probeVideoMetadata(buffer: Buffer): Promise<VideoProbe | null> {
-  if (!await hasCommand('ffprobe')) {
-    debug('ffprobe not found, skipping video validation');
+  if (!(await hasCommand("ffprobe"))) {
+    debug("ffprobe not found, skipping video validation");
     return null;
   }
 
   const tmpPath = await writeTempFile(buffer);
   try {
-    const result = await $`ffprobe -v error -show_format -show_streams -of json ${tmpPath}`.json();
+    const result =
+      await $`ffprobe -v error -show_format -show_streams -of json ${tmpPath}`.json();
     const format = result.format || {};
-    const videoStream = result.streams?.find((s: { codec_type: string }) => s.codec_type === 'video');
+    const videoStream = result.streams?.find(
+      (s: { codec_type: string }) => s.codec_type === "video",
+    );
 
     // Check for faststart by looking at format tags or probing atom order
     // A proper check would require parsing the file, but we can infer from tags
-    const hasFaststart = format.tags?.major_brand === 'isom' ||
-      format.format_name?.includes('mov') && format.tags?.compatible_brands?.includes('isom');
+    const hasFaststart =
+      format.tags?.major_brand === "isom" ||
+      (format.format_name?.includes("mov") &&
+        format.tags?.compatible_brands?.includes("isom"));
 
     return {
       duration: format.duration ? parseFloat(format.duration) : null,
@@ -588,7 +637,7 @@ async function probeVideoMetadata(buffer: Buffer): Promise<VideoProbe | null> {
       hasFaststart: !!hasFaststart,
     };
   } catch (e) {
-    debug('ffprobe failed', e instanceof Error ? e.message : String(e));
+    debug("ffprobe failed", e instanceof Error ? e.message : String(e));
     return null;
   } finally {
     await cleanupTempFiles(tmpPath);
@@ -604,9 +653,9 @@ async function probeVideo(buffer: Buffer): Promise<ProbeResult | null> {
   // Missing duration metadata - remux fixes this and also adds faststart
   if (probe.duration === null) {
     issues.push({
-      id: 'missing-duration',
-      description: 'Missing duration metadata',
-      severity: 'error',
+      id: "missing-duration",
+      description: "Missing duration metadata",
+      severity: "error",
       autoFix: true,
       fix: remuxVideo,
     });
@@ -614,9 +663,9 @@ async function probeVideo(buffer: Buffer): Promise<ProbeResult | null> {
   } else if (!probe.hasFaststart) {
     // Only check faststart if duration exists (otherwise remux already handles it)
     issues.push({
-      id: 'missing-faststart',
-      description: 'MP4 not optimized for streaming',
-      severity: 'warning',
+      id: "missing-faststart",
+      description: "MP4 not optimized for streaming",
+      severity: "warning",
       autoFix: true,
       fix: addFaststart,
     });
@@ -626,9 +675,9 @@ async function probeVideo(buffer: Buffer): Promise<ProbeResult | null> {
   if (probe.codec && INCOMPATIBLE_VIDEO_CODECS.includes(probe.codec)) {
     const isSmall = buffer.length < SIZE_THRESHOLDS.reencodeAuto;
     issues.push({
-      id: 'incompatible-codec',
+      id: "incompatible-codec",
       description: `Codec '${probe.codec}' has limited browser/Discord support`,
-      severity: 'warning',
+      severity: "warning",
       autoFix: isSmall,
       fix: reencodeVideo,
     });
@@ -637,49 +686,55 @@ async function probeVideo(buffer: Buffer): Promise<ProbeResult | null> {
   return { issues, metadata: probe };
 }
 
-async function probeImage(_buffer: Buffer, mime: string): Promise<ProbeResult | null> {
+async function probeImage(
+  _buffer: Buffer,
+  mime: string,
+): Promise<ProbeResult | null> {
   const issues: MediaIssue[] = [];
 
-  if (mime === 'image/heic' || mime === 'image/heif') {
+  if (mime === "image/heic" || mime === "image/heif") {
     issues.push({
-      id: 'heic-compat',
-      description: 'HEIC not supported in browsers',
-      severity: 'error',
+      id: "heic-compat",
+      description: "HEIC not supported in browsers",
+      severity: "error",
       autoFix: true,
       fix: convertImageToJpeg,
     });
   }
 
-  if (mime === 'image/avif') {
+  if (mime === "image/avif") {
     issues.push({
-      id: 'avif-compat',
-      description: 'AVIF has limited browser support',
-      severity: 'warning',
+      id: "avif-compat",
+      description: "AVIF has limited browser support",
+      severity: "warning",
       autoFix: true,
       fix: convertImageToWebp,
     });
   }
 
-  return issues.length > 0 ? { issues, metadata: { originalMime: mime } } : null;
+  return issues.length > 0
+    ? { issues, metadata: { originalMime: mime } }
+    : null;
 }
 
 async function probeAudio(buffer: Buffer): Promise<ProbeResult | null> {
-  if (!await hasCommand('ffprobe')) {
-    debug('ffprobe not found, skipping audio validation');
+  if (!(await hasCommand("ffprobe"))) {
+    debug("ffprobe not found, skipping audio validation");
     return null;
   }
 
   const tmpPath = await writeTempFile(buffer);
   try {
-    const result = await $`ffprobe -v error -show_format -of json ${tmpPath}`.json();
+    const result =
+      await $`ffprobe -v error -show_format -of json ${tmpPath}`.json();
     const format = result.format || {};
     const issues: MediaIssue[] = [];
 
-    if (!format.duration || format.duration === 'N/A') {
+    if (!format.duration || format.duration === "N/A") {
       issues.push({
-        id: 'missing-duration',
-        description: 'Missing duration metadata',
-        severity: 'error',
+        id: "missing-duration",
+        description: "Missing duration metadata",
+        severity: "error",
         autoFix: true,
         fix: remuxAudio,
       });
@@ -687,14 +742,20 @@ async function probeAudio(buffer: Buffer): Promise<ProbeResult | null> {
 
     return issues.length > 0 ? { issues, metadata: format } : null;
   } catch (e) {
-    debug('ffprobe failed for audio', e instanceof Error ? e.message : String(e));
+    debug(
+      "ffprobe failed for audio",
+      e instanceof Error ? e.message : String(e),
+    );
     return null;
   } finally {
     await cleanupTempFiles(tmpPath);
   }
 }
 
-async function validateMedia(buffer: Buffer, mimeType: string): Promise<ProbeResult | null> {
+async function validateMedia(
+  buffer: Buffer,
+  mimeType: string,
+): Promise<ProbeResult | null> {
   if (isVideoMime(mimeType)) {
     return probeVideo(buffer);
   } else if (isImageMime(mimeType)) {
@@ -710,11 +771,11 @@ async function applyFixes(
   mimeType: string,
   issues: MediaIssue[],
   mode: FixMode,
-  skipPrompts: boolean
+  skipPrompts: boolean,
 ): Promise<{ buffer: Buffer; mimeType: string; applied: string[] }> {
-  if (mode === 'never' || issues.length === 0) {
+  if (mode === "never" || issues.length === 0) {
     for (const issue of issues) {
-      log(`Skipped: ${issue.description}`, 'dim');
+      log(`Skipped: ${issue.description}`, "dim");
     }
     return { buffer, mimeType, applied: [] };
   }
@@ -722,15 +783,16 @@ async function applyFixes(
   const applied: string[] = [];
 
   for (const issue of issues) {
-    const shouldAuto = mode === 'always' || (mode === 'prompt' && issue.autoFix);
+    const shouldAuto =
+      mode === "always" || (mode === "prompt" && issue.autoFix);
 
     if (shouldAuto) {
-      log(`Fixing: ${issue.description}`, 'info');
+      log(`Fixing: ${issue.description}`, "info");
       buffer = await issue.fix(buffer);
       applied.push(issue.id);
-    } else if (mode === 'prompt') {
+    } else if (mode === "prompt") {
       if (skipPrompts) {
-        log(`Skipped: ${issue.description}`, 'dim');
+        log(`Skipped: ${issue.description}`, "dim");
         continue;
       }
 
@@ -743,24 +805,20 @@ async function applyFixes(
   }
 
   // Update mimeType based on applied fixes
-  if (applied.includes('heic-compat')) {
-    mimeType = 'image/jpeg';
-  } else if (applied.includes('avif-compat')) {
-    mimeType = 'image/webp';
-  } else if (applied.includes('incompatible-codec')) {
-    mimeType = 'video/mp4';
+  if (applied.includes("heic-compat")) {
+    mimeType = "image/jpeg";
+  } else if (applied.includes("avif-compat")) {
+    mimeType = "image/webp";
+  } else if (applied.includes("incompatible-codec")) {
+    mimeType = "video/mp4";
   }
 
   return { buffer, mimeType, applied };
 }
 
-// ============================================================================
-// Media Fix Functions
-// ============================================================================
-
 async function remuxVideo(buffer: Buffer): Promise<Buffer> {
   const spinner = new Spinner();
-  spinner.start('Remuxing video...');
+  spinner.start("Remuxing video...");
 
   const inputPath = await writeTempFile(buffer);
   const outputPath = join(tmpdir(), `share-remux-${nanoid(8)}.webm`);
@@ -771,11 +829,13 @@ async function remuxVideo(buffer: Buffer): Promise<Buffer> {
 
     const result = Buffer.from(await Bun.file(outputPath).arrayBuffer());
     spinner.stop();
-    log('Fixed video metadata', 'success');
+    log("Fixed video metadata", "success");
     return result;
   } catch (e) {
     spinner.stop();
-    throw new Error(`Video remux failed: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(
+      `Video remux failed: ${e instanceof Error ? e.message : String(e)}`,
+    );
   } finally {
     await cleanupTempFiles(inputPath, outputPath);
   }
@@ -783,7 +843,7 @@ async function remuxVideo(buffer: Buffer): Promise<Buffer> {
 
 async function addFaststart(buffer: Buffer): Promise<Buffer> {
   const spinner = new Spinner();
-  spinner.start('Optimizing for streaming...');
+  spinner.start("Optimizing for streaming...");
 
   const inputPath = await writeTempFile(buffer);
   const outputPath = join(tmpdir(), `share-faststart-${nanoid(8)}.mp4`);
@@ -793,11 +853,13 @@ async function addFaststart(buffer: Buffer): Promise<Buffer> {
 
     const result = Buffer.from(await Bun.file(outputPath).arrayBuffer());
     spinner.stop();
-    log('Optimized for streaming', 'success');
+    log("Optimized for streaming", "success");
     return result;
   } catch (e) {
     spinner.stop();
-    throw new Error(`Faststart optimization failed: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(
+      `Faststart optimization failed: ${e instanceof Error ? e.message : String(e)}`,
+    );
   } finally {
     await cleanupTempFiles(inputPath, outputPath);
   }
@@ -805,7 +867,7 @@ async function addFaststart(buffer: Buffer): Promise<Buffer> {
 
 async function reencodeVideo(buffer: Buffer): Promise<Buffer> {
   const spinner = new Spinner();
-  spinner.start('Re-encoding video for compatibility...');
+  spinner.start("Re-encoding video for compatibility...");
 
   const inputPath = await writeTempFile(buffer);
   const outputPath = join(tmpdir(), `share-reencode-${nanoid(8)}.mp4`);
@@ -815,11 +877,13 @@ async function reencodeVideo(buffer: Buffer): Promise<Buffer> {
 
     const result = Buffer.from(await Bun.file(outputPath).arrayBuffer());
     spinner.stop();
-    log('Re-encoded to H.264', 'success');
+    log("Re-encoded to H.264", "success");
     return result;
   } catch (e) {
     spinner.stop();
-    throw new Error(`Video re-encode failed: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(
+      `Video re-encode failed: ${e instanceof Error ? e.message : String(e)}`,
+    );
   } finally {
     await cleanupTempFiles(inputPath, outputPath);
   }
@@ -827,7 +891,7 @@ async function reencodeVideo(buffer: Buffer): Promise<Buffer> {
 
 async function remuxAudio(buffer: Buffer): Promise<Buffer> {
   const spinner = new Spinner();
-  spinner.start('Fixing audio metadata...');
+  spinner.start("Fixing audio metadata...");
 
   const inputPath = await writeTempFile(buffer);
   // Detect format and use same extension
@@ -838,11 +902,13 @@ async function remuxAudio(buffer: Buffer): Promise<Buffer> {
 
     const result = Buffer.from(await Bun.file(outputPath).arrayBuffer());
     spinner.stop();
-    log('Fixed audio metadata', 'success');
+    log("Fixed audio metadata", "success");
     return result;
   } catch (e) {
     spinner.stop();
-    throw new Error(`Audio remux failed: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(
+      `Audio remux failed: ${e instanceof Error ? e.message : String(e)}`,
+    );
   } finally {
     await cleanupTempFiles(inputPath, outputPath);
   }
@@ -850,7 +916,7 @@ async function remuxAudio(buffer: Buffer): Promise<Buffer> {
 
 async function convertImageToJpeg(buffer: Buffer): Promise<Buffer> {
   const spinner = new Spinner();
-  spinner.start('Converting to JPEG...');
+  spinner.start("Converting to JPEG...");
 
   const inputPath = await writeTempFile(buffer);
   const outputPath = join(tmpdir(), `share-convert-${nanoid(8)}.jpg`);
@@ -860,11 +926,13 @@ async function convertImageToJpeg(buffer: Buffer): Promise<Buffer> {
 
     const result = Buffer.from(await Bun.file(outputPath).arrayBuffer());
     spinner.stop();
-    log('Converted to JPEG', 'success');
+    log("Converted to JPEG", "success");
     return result;
   } catch (e) {
     spinner.stop();
-    throw new Error(`JPEG conversion failed: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(
+      `JPEG conversion failed: ${e instanceof Error ? e.message : String(e)}`,
+    );
   } finally {
     await cleanupTempFiles(inputPath, outputPath);
   }
@@ -872,7 +940,7 @@ async function convertImageToJpeg(buffer: Buffer): Promise<Buffer> {
 
 async function convertImageToWebp(buffer: Buffer): Promise<Buffer> {
   const spinner = new Spinner();
-  spinner.start('Converting to WebP...');
+  spinner.start("Converting to WebP...");
 
   const inputPath = await writeTempFile(buffer);
   const outputPath = join(tmpdir(), `share-convert-${nanoid(8)}.webp`);
@@ -882,28 +950,34 @@ async function convertImageToWebp(buffer: Buffer): Promise<Buffer> {
 
     const result = Buffer.from(await Bun.file(outputPath).arrayBuffer());
     spinner.stop();
-    log('Converted to WebP', 'success');
+    log("Converted to WebP", "success");
     return result;
   } catch (e) {
     spinner.stop();
-    throw new Error(`WebP conversion failed: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(
+      `WebP conversion failed: ${e instanceof Error ? e.message : String(e)}`,
+    );
   } finally {
     await cleanupTempFiles(inputPath, outputPath);
   }
 }
 
-// ============================================================================
-// Original Conversion Functions (kept for -c flag compatibility)
-// ============================================================================
-
-async function convertImage(buffer: Buffer, fromMime: string, shouldConvert: boolean): Promise<Buffer> {
-  const needsConversion = fromMime === 'image/bmp' ||
-    (shouldConvert && (fromMime === 'image/heic' || fromMime === 'image/heif' || fromMime === 'image/tiff'));
+async function convertImage(
+  buffer: Buffer,
+  fromMime: string,
+  shouldConvert: boolean,
+): Promise<Buffer> {
+  const needsConversion =
+    fromMime === "image/bmp" ||
+    (shouldConvert &&
+      (fromMime === "image/heic" ||
+        fromMime === "image/heif" ||
+        fromMime === "image/tiff"));
 
   if (!needsConversion) return buffer;
 
   const spinner = new Spinner();
-  spinner.start('Converting image...');
+  spinner.start("Converting image...");
 
   const inputPath = join(tmpdir(), `share-input-${nanoid(8)}`);
   const outputPath = join(tmpdir(), `share-output-${nanoid(8)}.png`);
@@ -911,7 +985,7 @@ async function convertImage(buffer: Buffer, fromMime: string, shouldConvert: boo
   try {
     await Bun.write(inputPath, buffer);
 
-    if (fromMime === 'image/heic' || fromMime === 'image/heif') {
+    if (fromMime === "image/heic" || fromMime === "image/heif") {
       await $`convert ${inputPath} -quality 90 ${outputPath}`.quiet();
     } else {
       await $`convert ${inputPath} ${outputPath}`.quiet();
@@ -920,12 +994,14 @@ async function convertImage(buffer: Buffer, fromMime: string, shouldConvert: boo
     const converted = Buffer.from(await Bun.file(outputPath).arrayBuffer());
 
     spinner.stop();
-    log(`Converted to ${fromMime === 'image/bmp' ? 'PNG' : 'JPEG'}`, 'success');
+    log(`Converted to ${fromMime === "image/bmp" ? "PNG" : "JPEG"}`, "success");
 
     return converted;
   } catch (e) {
     spinner.stop();
-    throw new Error(`Image conversion failed: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(
+      `Image conversion failed: ${e instanceof Error ? e.message : String(e)}`,
+    );
   } finally {
     await cleanupTempFiles(inputPath, outputPath);
   }
@@ -933,7 +1009,7 @@ async function convertImage(buffer: Buffer, fromMime: string, shouldConvert: boo
 
 async function convertVideo(buffer: Buffer): Promise<Buffer> {
   const spinner = new Spinner();
-  spinner.start('Converting video (this may take a while)...');
+  spinner.start("Converting video (this may take a while)...");
 
   const inputPath = join(tmpdir(), `share-input-${nanoid(8)}`);
   const outputPath = join(tmpdir(), `share-output-${nanoid(8)}.mp4`);
@@ -946,12 +1022,14 @@ async function convertVideo(buffer: Buffer): Promise<Buffer> {
     const converted = Buffer.from(await Bun.file(outputPath).arrayBuffer());
 
     spinner.stop();
-    log('Converted to web-optimized MP4', 'success');
+    log("Converted to web-optimized MP4", "success");
 
     return converted;
   } catch (e) {
     spinner.stop();
-    throw new Error(`Video conversion failed: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(
+      `Video conversion failed: ${e instanceof Error ? e.message : String(e)}`,
+    );
   } finally {
     await cleanupTempFiles(inputPath, outputPath);
   }
@@ -960,20 +1038,27 @@ async function convertVideo(buffer: Buffer): Promise<Buffer> {
 async function uploadToR2(
   buffer: Buffer,
   filename: string,
-  mimeType: string
+  mimeType: string,
 ): Promise<UploadResult> {
-  if (!ENV.endpoint || !ENV.accessKeyId || !ENV.secretAccessKey || !ENV.bucket) {
-    throw new Error('Missing R2 credentials - ensure all R2_* environment variables are set');
+  if (
+    !ENV.endpoint ||
+    !ENV.accessKeyId ||
+    !ENV.secretAccessKey ||
+    !ENV.bucket
+  ) {
+    throw new Error(
+      "Missing R2 credentials - ensure all R2_* environment variables are set",
+    );
   }
 
-  debug('S3 Client Config', {
+  debug("S3 Client Config", {
     endpoint: ENV.endpoint,
     bucket: ENV.bucket,
     accessKeyIdLength: ENV.accessKeyId.length,
   });
 
   const client = new S3Client({
-    region: 'auto',
+    region: "auto",
     endpoint: ENV.endpoint,
     credentials: {
       accessKeyId: ENV.accessKeyId,
@@ -986,10 +1071,10 @@ async function uploadToR2(
 
   const now = new Date();
   const year = now.getFullYear();
-  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const month = String(now.getMonth() + 1).padStart(2, "0");
   const key = `${year}/${month}/${filename}`;
 
-  debug('Uploading to R2', { key, size: buffer.length, mimeType });
+  debug("Uploading to R2", { key, size: buffer.length, mimeType });
 
   const progressBar = new ProgressBar(buffer.length);
 
@@ -1004,7 +1089,7 @@ async function uploadToR2(
       },
     });
 
-    upload.on('httpUploadProgress', (progress) => {
+    upload.on("httpUploadProgress", (progress) => {
       if (progress.loaded) {
         progressBar.update(progress.loaded);
       }
@@ -1015,31 +1100,36 @@ async function uploadToR2(
     let timeoutId: TimeoutHandle;
     const uploadPromise = upload.done();
     const timeoutPromise = new Promise((_, reject) => {
-      timeoutId = setTimeout(() => reject(new Error('Upload timeout after 60 seconds')), TIMING.uploadTimeout);
+      timeoutId = setTimeout(
+        () => reject(new Error("Upload timeout after 60 seconds")),
+        TIMING.uploadTimeout,
+      );
     });
 
-    debug('Waiting for upload to complete...');
+    debug("Waiting for upload to complete...");
     try {
       await Promise.race([uploadPromise, timeoutPromise]);
-      debug('Upload promise resolved');
+      debug("Upload promise resolved");
     } finally {
       clearTimeout(timeoutId!);
     }
     progressBar.finish();
-    debug('Progress bar finished');
+    debug("Progress bar finished");
 
     upload.removeAllListeners();
-    debug('Event listeners removed');
+    debug("Event listeners removed");
 
     const url = `${DOMAIN}/${key}`;
-    debug('Returning result');
+    debug("Returning result");
     return { url, key, size: buffer.length };
   } catch (e) {
     progressBar.finish();
     if (VERBOSE && e instanceof Error) {
-      debug('Upload error details', { error: e.message, stack: e.stack });
+      debug("Upload error details", { error: e.message, stack: e.stack });
     }
-    throw new Error(`Upload failed: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(
+      `Upload failed: ${e instanceof Error ? e.message : String(e)}`,
+    );
   } finally {
     client.destroy();
   }
@@ -1054,27 +1144,27 @@ async function main() {
   const { values, positionals } = parseArgs({
     args: Bun.argv.slice(2),
     options: {
-      verbose: { type: 'boolean', short: 'v' },
-      convert: { type: 'boolean', short: 'c' },
-      fix: { type: 'string', short: 'F' },
-      yes: { type: 'boolean', short: 'y' },
-      name: { type: 'string', short: 'n' },
-      help: { type: 'boolean', short: 'h' },
+      verbose: { type: "boolean", short: "v" },
+      convert: { type: "boolean", short: "c" },
+      fix: { type: "string", short: "F" },
+      yes: { type: "boolean", short: "y" },
+      name: { type: "string", short: "n" },
+      help: { type: "boolean", short: "h" },
     },
     allowPositionals: true,
   });
 
   if (values.help) {
     console.log(`
-${chalk.hex(COLORS.success)('share')} - Upload files to R2 and copy the URL to clipboard
+${chalk.hex(COLORS.success)("share")} - Upload files to R2 and copy the URL to clipboard
 
-${chalk.hex(COLORS.label)('Usage:')}
+${chalk.hex(COLORS.label)("Usage:")}
   share [options] [file]
 
-${chalk.hex(COLORS.label)('Arguments:')}
+${chalk.hex(COLORS.label)("Arguments:")}
   file                Optional file path to upload
 
-${chalk.hex(COLORS.label)('Options:')}
+${chalk.hex(COLORS.label)("Options:")}
   -v, --verbose       Enable debug output
   -c, --convert       Convert media before upload (re-encode video, etc.)
   -F, --fix <mode>    Fix media issues: n=never, p=prompt (default), a=always
@@ -1082,28 +1172,28 @@ ${chalk.hex(COLORS.label)('Options:')}
   -n, --name <name>   Custom filename (without extension)
   -h, --help          Show this help
 
-${chalk.hex(COLORS.label)('Fix Modes:')}
+${chalk.hex(COLORS.label)("Fix Modes:")}
   -Fn, --fix=never    Skip all fixes, upload as-is
   -Fp, --fix=prompt   Auto-fix quick/lossless, prompt for slow/lossy (default)
   -Fa, --fix=always   Apply all fixes automatically
 
-${chalk.hex(COLORS.label)('Media Fixes (auto-applied by default):')}
+${chalk.hex(COLORS.label)("Media Fixes (auto-applied by default):")}
   • Missing video duration/metadata (remux)
   • MP4 streaming optimization (faststart)
   • HEIC/AVIF browser compatibility (convert to JPEG/WebP)
 
-${chalk.hex(COLORS.label)('Media Fixes (prompted or with -Fa):')}
+${chalk.hex(COLORS.label)("Media Fixes (prompted or with -Fa):")}
   • Video re-encoding for codec compatibility (H.265/AV1 → H.264)
   • Large file optimizations
 
-${chalk.hex(COLORS.label)('Examples:')}
+${chalk.hex(COLORS.label)("Examples:")}
   share                      # Upload clipboard content
   share screenshot.png       # Upload specific file
   cat file.txt | share       # Upload from stdin
   share -c large-video.mov   # Convert/re-encode then upload
   share -Fa video.webm       # Fix all issues automatically
 
-${chalk.hex(COLORS.label)('Environment Variables:')}
+${chalk.hex(COLORS.label)("Environment Variables:")}
   R2_ENDPOINT              S3-compatible endpoint URL
   R2_ACCESS_KEY_ID         Access key ID
   R2_SECRET_ACCESS_KEY     Secret access key
@@ -1114,9 +1204,9 @@ ${chalk.hex(COLORS.label)('Environment Variables:')}
 
   VERBOSE = values.verbose || false;
 
-  const missing = REQUIRED_ENV.filter(key => !process.env[key]);
+  const missing = REQUIRED_ENV.filter((key) => !process.env[key]);
   if (missing.length > 0) {
-    log(`Missing environment variables: ${missing.join(', ')}`, 'error');
+    log(`Missing environment variables: ${missing.join(", ")}`, "error");
     process.exit(1);
   }
 
@@ -1137,58 +1227,67 @@ ${chalk.hex(COLORS.label)('Environment Variables:')}
       mimeType = await detectMimeType(buffer, filename);
     }
 
-    log(`Detected: ${mimeType} (${formatBytes(buffer.length)})`, 'success');
+    log(`Detected: ${mimeType} (${formatBytes(buffer.length)})`, "success");
 
     if (isTextMime(mimeType) && !values.yes) {
       const ext = await promptExtension();
       if (!ext) {
-        log('Upload cancelled', 'error');
+        log("Upload cancelled", "error");
         process.exit(0);
       }
 
       mimeType = getMimeForExtension(ext);
-      const baseName = values.name || (filename ? basename(filename, extname(filename)) : 'text');
+      const baseName =
+        values.name ||
+        (filename ? basename(filename, extname(filename)) : "text");
       filename = `${baseName}-${nanoid(8)}.${ext}`;
     }
 
     // Determine fix mode: -c implies -Fa (always fix), otherwise parse -F flag
-    const fixMode = values.convert ? 'always' : parseFixMode(values.fix);
+    const fixMode = values.convert ? "always" : parseFixMode(values.fix);
 
     // Validate and fix media issues
-    if (fixMode !== 'never') {
+    if (fixMode !== "never") {
       const probeResult = await validateMedia(buffer, mimeType);
 
       if (probeResult && probeResult.issues.length > 0) {
-        debug('Media issues detected', probeResult.metadata);
+        debug("Media issues detected", probeResult.metadata);
 
         const fixResult = await applyFixes(
           buffer,
           mimeType,
           probeResult.issues,
           fixMode,
-          values.yes || false
+          values.yes || false,
         );
 
         buffer = fixResult.buffer;
         mimeType = fixResult.mimeType;
 
         if (fixResult.applied.length > 0) {
-          debug('Applied fixes', fixResult.applied);
+          debug("Applied fixes", fixResult.applied);
         }
       }
     }
 
     if (!values.yes) {
       let needsConfirm = false;
-      let reason = '';
+      let reason = "";
 
       if (isImageMime(mimeType) && buffer.length > SIZE_THRESHOLDS.image) {
         needsConfirm = true;
         reason = `image is larger than ${formatBytes(SIZE_THRESHOLDS.image)}`;
-      } else if (isVideoMime(mimeType) && buffer.length > SIZE_THRESHOLDS.video) {
+      } else if (
+        isVideoMime(mimeType) &&
+        buffer.length > SIZE_THRESHOLDS.video
+      ) {
         needsConfirm = true;
         reason = `video is larger than ${formatBytes(SIZE_THRESHOLDS.video)}`;
-      } else if (!isImageMime(mimeType) && !isVideoMime(mimeType) && buffer.length > SIZE_THRESHOLDS.binary) {
+      } else if (
+        !isImageMime(mimeType) &&
+        !isVideoMime(mimeType) &&
+        buffer.length > SIZE_THRESHOLDS.binary
+      ) {
         needsConfirm = true;
         reason = `file is larger than ${formatBytes(SIZE_THRESHOLDS.binary)}`;
       }
@@ -1196,25 +1295,25 @@ ${chalk.hex(COLORS.label)('Environment Variables:')}
       if (needsConfirm) {
         const shouldContinue = await confirm(`Upload large file? (${reason})`);
         if (!shouldContinue) {
-          log('Upload cancelled', 'error');
+          log("Upload cancelled", "error");
           process.exit(0);
         }
       }
     }
 
     // Legacy conversion path: BMP always converts, -c triggers full re-encode
-    if (isImageMime(mimeType) && mimeType === 'image/bmp') {
+    if (isImageMime(mimeType) && mimeType === "image/bmp") {
       buffer = await convertImage(buffer, mimeType, false);
-      mimeType = 'image/png';
+      mimeType = "image/png";
     } else if (isVideoMime(mimeType) && values.convert) {
       // Full video conversion (re-encode with scaling, etc.) only with -c
       buffer = await convertVideo(buffer);
-      mimeType = 'video/mp4';
+      mimeType = "video/mp4";
     }
 
     if (!filename) {
       const ext = getExtensionForMime(mimeType);
-      const baseName = values.name || 'upload';
+      const baseName = values.name || "upload";
       filename = `${baseName}-${nanoid(8)}.${ext}`;
     } else if (!hasNanoidSuffix(filename)) {
       const ext = extname(filename);
@@ -1223,27 +1322,27 @@ ${chalk.hex(COLORS.label)('Environment Variables:')}
       filename = `${finalName}-${nanoid(8)}${ext}`;
     }
 
-    debug('Calling uploadToR2...');
+    debug("Calling uploadToR2...");
     const result = await uploadToR2(buffer, filename, mimeType);
-    debug('uploadToR2 returned', { url: result.url });
+    debug("uploadToR2 returned", { url: result.url });
 
-    debug('Copying to clipboard...');
+    debug("Copying to clipboard...");
     await copyToClipboard(result.url);
-    debug('Clipboard copy complete');
+    debug("Clipboard copy complete");
 
-    log(result.url, 'success');
-    log('Copied to clipboard', 'success');
+    log(result.url, "success");
+    log("Copied to clipboard", "success");
 
-    debug('About to exit...');
+    debug("About to exit...");
     if (usedStdin) {
       process.stdin.destroy();
     }
     process.exit(0);
   } catch (e) {
     if (e instanceof Error) {
-      log(e.message, 'error');
+      log(e.message, "error");
     } else {
-      log('Unknown error occurred', 'error');
+      log("Unknown error occurred", "error");
     }
     process.exit(1);
   }