Can I vibecode ScreenFlow?

You are an expert AI coding assistant. Your task is to build a complete, production-ready, locally-hosted web application that replicates the core features of ScreenFlow.

# Tech Stack & Architecture
- Frontend: React (using Next.js or Vite), Tailwind CSS for styling, Framer Motion for micro-animations, and Lucide React for iconography.
- Backend: Node.js with Express or Python with FastAPI (whichever fits the processing needs better), using SQLite for local persistence.
- Design: The UI must be incredibly polished, using a modern aesthetic (e.g., glassmorphism, dark mode by default, highly readable typography like Inter or Roboto, and accessible contrast ratios).

# Core Functionality to Implement
- Screen Recording: Implement local Mac/PC screen recording capture functionality (importing user-provided video files or using local WebRTC capture).
- Timeline Editing: Build a comprehensive non-linear video editing timeline with multiple tracks for video, audio, and text callouts.
- Transformations & Effects: Allow non-destructive cropping, zooming, cursor highlighting, and adding text annotations.
- Preview & Playback: Create a high-performance preview window for the video being edited.
- Video Export: Use local FFmpeg to render the final composition to a standard MP4 file with optimized presets.

# Detailed Requirements
1. **User Interface & Experience:**
   - Build a stunning landing/dashboard page with an empty state that clearly guides the user to upload or process their first item.
   - Implement real-time progress indicators (e.g., circular progress bars, skeleton loaders) during long-running tasks.
   - Ensure the application is fully responsive. Mobile layouts should gracefully stack elements, while desktop layouts should take advantage of widescreen real estate for complex timelines or data tables.
   - Add hover states, active states, and subtle layout transitions using Framer Motion so the application feels alive and premium.

2. **Backend & Processing:**
   - Set up a secure and modular backend structure. All environment variables (like API keys for LLMs or external services) must be loaded from a `.env` file. Provide a `.env.example`.
   - Implement robust error handling. If a processing step fails, the UI should gracefully explain the issue and allow the user to retry without losing their session context.
   - For audio/video processing, use local instances of FFmpeg. For transcription or AI tasks, integrate with OpenAI's API or use local models (like Whisper.cpp or Ollama) to guarantee privacy and control.
   - Data should be saved locally in a SQLite database with schemas that clearly link media assets to their processed metadata (transcripts, summaries, edit markers).

3. **Application State & Export:**
   - Use standard state management (like Zustand or React Context) to manage the user's current project.
   - Provide a highly visible "Export" mechanism. Users should be able to download their final assets (e.g., Markdown files, MP3/MP4 files, JSON manifests) with a single click in a nicely packaged format.

4. **Code Quality & Constraints:**
   - Write clean, modular, and well-documented code. Split React components into logical, reusable pieces (e.g., `MediaUploader`, `TimelineEditor`, `TranscriptView`).
   - Do not implement any user authentication, cloud syncing, billing, or telemetry. This is a strictly local, single-player application designed for maximum privacy and utility.
   - Do not hallucinate external integrations (like CRM syncing or automatic publishing to platforms). Keep the scope strictly to local processing and export.
   - Include a comprehensive README.md detailing the exact commands to install dependencies, start the frontend and backend servers, and any system-level prerequisites (like installing FFmpeg).

Begin your implementation by setting up the project scaffolding, then build the UI skeleton, integrate the backend processing pipelines, and finally polish the UI with animations and responsive tweaks.