release: v1.4.5

CHANGELOG.md

@@ -4,7 +4,64 @@ All notable changes to Clypra will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [1.4.5] - 2026-08-27
+
+### 🔤 Native GPU SDF Text Engine & Font Registry
+- **Native Signed Distance Field (SDF) text rendering** — migrated text rendering from browser canvas to GPU-accelerated wgpu/WGSL SDF shaders for razor-sharp typography at any preview scale.
+- **Native font registry & WOFF2 support** — added `register_native_font` / `register_native_font_bytes` IPC commands; native core automatically decodes bundled WOFF2 and TTF fonts via `woff2-patched`.
+- **Per-glyph font fallback & Noto Emoji** — `render_text_sdf_aligned_with_fallback` seamlessly resolves missing glyphs to the bundled `@fontsource/noto-emoji` fallback font.
+- **Synthetic weight & italic transforms** — pre-SDF bitmap dilation and skewing synthesize bold and italic styles for single-weight fonts.
+- **Contract v2 text snapshots** — extended native contract to v2, introducing text runs for timed karaoke/captions, vertical alignment, and multi-pass text shaders.
+- **Native text templates & compound clip reuse** — text templates instantiate natively with full styling and shader passes preserved across export and preview.
+- **Retired browser text rasterization** — desktop preview and export render text layers directly via wgpu, removing canvas raster roundtrips and DOM bottlenecks.
+
+### 🔊 Professional Audio Engine & Timeline Controls
+- **Extended native audio mixer** — Rust mixer supports fade-in / fade-out curves, keyframe interpolation, pan, channel routing, and pitch preservation.
+- **Interactive audio envelope editor** — CapCut-style volume rubber bands and fade handle knobs directly on clips with cubic Bézier curves.
+- **J/L-cut audio unlinking** — added `UnlinkAudioCommand` and `RelinkAudioCommand` for independent audio/video trimming and J/L cut workflows.
+- **Atomic audio graph updates** — `replaceNativeAudioClips` IPC synchronizes audio edits in-place without restarting playback decoders.
+- **Desktop Web Audio engine** — browser desktop audio path honors clip-level `preservePitch` with smooth time-stretching.
+- **Waveform fade curves & solo button** — waveforms render overlaid fade curves with source-scoped peak caching and per-track solo controls.
+
+### 🔄 Session-Safe Deferred Updates & Auto-Updater Pipeline
+- **Two-stage update lifecycle** — separated update download from installation via `AutoUpdateManager` singleton; active editing sessions are never interrupted.
+- **Save-before-update verification** — transport playback is paused and project state is atomically saved and verified before update restart; save failures abort installation safely.
+- **Unified updater state** — synchronized update notifications, downloading status, and restart prompts across SettingsModal and UpdateBanner.
+
+### 💾 Project Persistence Reliability & Crash Recovery
+- **Atomic save pipeline** — verified candidate write (`.tmp`), generation rotation (`.bak`), and atomic file replacement with save receipt verification.
+- **Transactional project hydration** — `validateAndMigrateProjectPayload` safely migrates legacy project fields; hydration failures roll back to the previously active project.
+- **Failure-isolated recent projects** — corrupt or unreadable projects no longer hide valid projects and offer one-click recovery from verified backup files.
+- **Crash recovery snapshot v2** — IndexedDB snapshot persists timeline gaps, markers, and schema version.
+- **Cross-platform save hardening** — resolved Windows backup rename races and mobile Capacitor overwrite/rename paths.
+
+### 🖥️ Dual-Monitor Workspace & Preview Layouts
+- **Dual-monitor preview workspace** — added `PreviewMonitorWorkspace` supporting configurable side-by-side row and stacked column orientations for Source and Program monitors.
+- **Independent preview panels** — `PreviewPanel` supports an explicit `mode` prop ("program" vs "source") regardless of global preview state.
+- **Interaction-deferred transport context** — `SourcePreview` defers transport claiming until user interaction, preventing accidental playback hijacking on mount.
+
+### 🎨 Design System, Semantic Tokens & Clip Palettes
+- **Per-theme clip palettes** — clip colors derive from dynamic semantic design tokens (`--clypra-clip-*`) mapped 1-to-1 with UI themes.
+- **Full palette fidelity** — eliminated heavy CSS saturation and opacity filters that dulled theme palette colors.
+- **Live theme preview swatches** — Settings theme swatches preview actual built-in clip palette color schemes.
+
+### 📐 Timeline Viewport Precision & Interactions
+- **Sub-pixel alignment & 20px clip-start offset** — consistent timeline coordinates across Ruler, Clips, Playhead, Gaps, and mouse/wheel seek anchors via `TIMELINE_CLIP_START_OFFSET_PX`.
+- **Refined visual hierarchy** — distinct A-roll (primary) and B-roll visual roles with dedicated track heights.
+- **Visual track ordering guards** — visual tracks are prevented from being placed below the main video track, enforced across drag/drop and history undo/redo.
+- **CapCut-style ruler** — clean ticks with compact `MM:SS` formatting under one hour and `HH:MM:SS` timecodes for longer projects.
+- **Spring-animated zoom & canonical overview** — buttery-smooth anchored wheel zoom with spring physics; projects reliably open at standard minimum zoom.
+
+### ⚡ Performance, Telemetry & Lookahead Pre-fetching
+- **Zero-PII performance telemetry** — lightweight client and collector reporting stage timings and dropped frames with adaptive sampling.
+- **Bounded lookahead pre-fetching** — predictive decoding warms upcoming clip assets within a 3-second horizon without saturating GPU presentation.
+- **Event-driven paused render loop** — native preview pauses RAF loops while stopped, waking instantaneously on state and transform changes.
+- **24-track compositor density** — validated multi-track layer pooling and composition stability up to 24 concurrent tracks.
+
+### 🛠️ UI Polish & Workflow Shortcuts
+- **Collapsible properties panel** — 44px collapsed rail with expand button and shortcut icons; `Alt+P` / `Cmd+Shift+P` toggle shortcut.
+- **Media library shortcut** — `Cmd+B` toggles the media library drawer.
+- **Transform overlay polish** — RAF-throttled gizmo tracking, enlarged hit targets, and diagonal resize cursors.
 
 ## [1.4.4] - 2026-08-25
 

README.md

@@ -10,7 +10,7 @@ A modern video editor built on Tauri v2, React 19, and Rust with hardware-accele
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md) [![GitHub issues](https://img.shields.io/github/issues/AIEraDev/clypra)](https://github.com/AIEraDev/clypra/issues) [![GitHub stars](https://img.shields.io/github/stars/AIEraDev/clypra)](https://github.com/AIEraDev/clypra/stargazers) [![GitHub Sponsors](https://img.shields.io/github/sponsors/AIEraDev?label=Sponsors&logo=githubsponsors&color=EA4AAA)](SPONSORS.md)
 
-[Features](#features) • [Architecture](#architecture) • [Installation](#installation) • [Development](#development) • [Contributing](CONTRIBUTING.md)
+[Features](#key-features) • [Architecture](#architecture) • [⚡ Performance Telemetry](#-production-performance-telemetry--privacy) • [Installation](#installation) • [Development](#development) • [Contributing](CONTRIBUTING.md)
 
 </div>
 
@@ -34,6 +34,20 @@ Clypra is a **free, open-source video editor** (MIT License) with professional-g
 - 🎵 **High-Fidelity Audio & Waveforms** — Real-time peak + RMS waveform rendering, frame-accurate AV sync, and clip volume controls.
 - 🎨 **Text & Visual Compositing** — Custom text styling, animated overlays, filters, and real-time canvas previews.
 - 📦 **Multi-Format Import & Export** — Support for MP4, MOV, WebM, MKV, MP3, WAV, PNG, and high-quality ProRes/H.264 export.
+- 🛡️ **Zero-Overhead Performance Telemetry** — Production-only frame timing analysis to optimize driver compatibility and cross-OS rendering with zero PII.
+
+---
+
+## ⚡ Production Performance Telemetry & Privacy
+
+To ensure stutter-free 60 FPS playback and diagnose edge-case GPU driver regressions across diverse hardware configurations, Clypra includes a lightweight, non-blocking telemetry collector:
+
+- **What We Collect**: High-level numerical timings (decode $\mu$s, compose $\mu$s, P95 seek latency, dropped frame counts, OS family, and GPU vendor/model).
+- **Strict Privacy (Zero PII)**: Zero video frames, media assets, project titles, file paths, or personal user identities are ever accessed or sent.
+- **Adaptive Sampling**: Smooth 60 FPS playback is sampled at 1%, while dropped frames ($>5\%$) and driver fallbacks are captured at 100% to isolate regressions without impacting playback frame pacing.
+- **Analysis Hub**: Aggregated performance metrics are analyzed by engineers in the [Clypra Studio Admin Console](https://github.com/AIEraDev/clypra-studio) (`/studio/admin`).
+
+For technical details, see the [Performance Telemetry Specification](docs/performance-telemetry.md).
 
 ---
 
@@ -65,7 +79,8 @@ Clypra is built with a native Rust/Tauri v2 core for hardware video operations,
 ```
 
 For performance benchmarks and technical deep-dives, see the
-[Native Performance Contract](docs/performance-contract.md) and the
+[Native Performance Contract](docs/performance-contract.md), the
+[Performance Telemetry Specification](docs/performance-telemetry.md), and the
 [Program Preview Performance Runbook](docs/program-preview-performance-runbook.md).
 
 ---

crates/clypra-native-core/Cargo.toml

@@ -9,3 +9,6 @@ license = "MIT"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 sha2 = "0.10"
+fontdue = "0.9"
+parking_lot = "0.12"
+woff2 = { package = "woff2-patched", version = "0.4" }

crates/clypra-native-core/src/font_registry.rs

@@ -0,0 +1,208 @@
+//! Font Registry — In-memory, thread-safe TrueType / OpenType font repository.
+//!
+//! Maps font identifiers (e.g. "inter-regular", "roboto-bold") to parsed `fontdue::Font`
+//! instances and content hashes. The compatibility lookup retains a bundled default;
+//! authoritative rendering uses `require_font` and fails on missing registrations.
+
+use fontdue::{Font, FontSettings};
+use parking_lot::RwLock;
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+use std::io::Cursor;
+use std::sync::{Arc, OnceLock};
+
+/// Bundled compatibility font bytes (Inconsolata Regular).
+pub const DEFAULT_FONT_BYTES: &[u8] = include_bytes!("../tests/test_font.ttf");
+pub const DEFAULT_FONT_ID: &str = "default";
+/// Internal face used for glyphs missing from the selected editor font.
+pub const EMOJI_FALLBACK_FONT_ID: &str = "__clypra_noto_emoji";
+
+/// Thread-safe registry of parsed TrueType / OpenType fonts.
+pub struct FontRegistry {
+    fonts: RwLock<HashMap<String, (Arc<Font>, u64)>>,
+    missing_warnings: RwLock<Vec<String>>,
+}
+
+impl FontRegistry {
+    /// Creates a new font registry initialized with the bundled default font.
+    pub fn new() -> Self {
+        let registry = Self {
+            fonts: RwLock::new(HashMap::new()),
+            missing_warnings: RwLock::new(Vec::new()),
+        };
+
+        // Register default fallback font
+        let _ = registry.register_font(DEFAULT_FONT_ID, DEFAULT_FONT_BYTES);
+        registry
+    }
+
+    /// Register a font from raw TTF/OTF bytes.
+    /// Returns the 64-bit content hash of the registered font.
+    pub fn register_font(&self, font_id: &str, font_bytes: &[u8]) -> Result<u64, String> {
+        if font_id.trim().is_empty() {
+            return Err("Native font id must not be empty".to_string());
+        }
+
+        // The web editor bundles fonts as WOFF2. Convert at the native
+        // boundary so the same deterministic registration API accepts both
+        // editor assets and user-provided TTF/OTF files.
+        let decoded_woff2;
+        let parse_bytes = if woff2::decode::is_woff2(font_bytes) {
+            decoded_woff2 = woff2::convert_woff2_to_ttf(&mut Cursor::new(font_bytes))
+                .map_err(|error| format!("Failed to decode WOFF2 font '{font_id}': {error}"))?;
+            decoded_woff2.as_slice()
+        } else {
+            font_bytes
+        };
+        let font = Font::from_bytes(parse_bytes, FontSettings::default())
+            .map_err(|e| format!("Failed to parse font '{font_id}': {e}"))?;
+
+        // Compute 64-bit content hash of font bytes
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        font_bytes.hash(&mut hasher);
+        font_id.hash(&mut hasher);
+        let font_hash = hasher.finish();
+
+        let mut write = self.fonts.write();
+        write.insert(font_id.to_lowercase(), (Arc::new(font), font_hash));
+        Ok(font_hash)
+    }
+
+    /// Retrieve a font by identifier. If the requested font is not found,
+    /// falls back to the bundled default font and records a diagnostic warning.
+    pub fn get_font(&self, font_id: &str) -> (Arc<Font>, u64) {
+        let (font, hash, _) = self.get_font_with_status(font_id);
+        (font, hash)
+    }
+
+    /// Retrieve a font by identifier, returning `(font, font_hash, is_fallback)`.
+    /// `is_fallback` is `true` when the requested font was missing and fell back to default.
+    pub fn get_font_with_status(&self, font_id: &str) -> (Arc<Font>, u64, bool) {
+        let key = font_id.to_lowercase();
+        let read = self.fonts.read();
+        if let Some(entry) = read.get(&key) {
+            return (Arc::clone(&entry.0), entry.1, false);
+        }
+
+        // Record missing font warning
+        drop(read);
+        {
+            let mut warnings = self.missing_warnings.write();
+            let msg = format!("Requested font '{font_id}' is not installed; fell back to '{DEFAULT_FONT_ID}'");
+            if !warnings.contains(&msg) {
+                warnings.push(msg);
+            }
+        }
+
+        let read = self.fonts.read();
+        // Fallback to default font
+        if let Some(default_entry) = read.get(DEFAULT_FONT_ID) {
+            return (Arc::clone(&default_entry.0), default_entry.1, true);
+        }
+
+        drop(read);
+        // If even default was missing, re-register and return it
+        let _ = self.register_font(DEFAULT_FONT_ID, DEFAULT_FONT_BYTES);
+        let read = self.fonts.read();
+        let entry = read.get(DEFAULT_FONT_ID).expect("Default font must be registered");
+        (Arc::clone(&entry.0), entry.1, true)
+    }
+
+    /// Strict lookup used by authoritative desktop rendering. Browser-style
+    /// fallback is intentionally kept only for compatibility/diagnostic APIs.
+    pub fn require_font(&self, font_id: &str) -> Result<(Arc<Font>, u64), String> {
+        let key = font_id.to_lowercase();
+        self.fonts
+            .read()
+            .get(&key)
+            .map(|entry| (Arc::clone(&entry.0), entry.1))
+            .ok_or_else(|| format!("Native font '{font_id}' is not registered"))
+    }
+
+    /// Retrieve all missing font warnings accumulated during font lookups.
+    pub fn get_missing_font_warnings(&self) -> Vec<String> {
+        self.missing_warnings.read().clone()
+    }
+
+    /// Clear accumulated missing font warnings.
+    pub fn clear_missing_font_warnings(&self) {
+        self.missing_warnings.write().clear();
+    }
+
+    /// Checks whether a specific font is registered.
+    pub fn has_font(&self, font_id: &str) -> bool {
+        let key = font_id.to_lowercase();
+        self.fonts.read().contains_key(&key)
+    }
+
+    /// Returns list of all registered font IDs.
+    pub fn list_fonts(&self) -> Vec<String> {
+        self.fonts.read().keys().cloned().collect()
+    }
+}
+
+impl Default for FontRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+static GLOBAL_FONT_REGISTRY: OnceLock<FontRegistry> = OnceLock::new();
+
+/// Process-global font registry singleton.
+pub fn global_font_registry() -> &'static FontRegistry {
+    GLOBAL_FONT_REGISTRY.get_or_init(FontRegistry::new)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn default_font_is_always_registered() {
+        let reg = FontRegistry::new();
+        assert!(reg.has_font("default"));
+        let (font, hash, is_fallback) = reg.get_font_with_status("default");
+        assert!(hash > 0);
+        assert!(!is_fallback);
+        assert!(font.glyph_count() > 0);
+    }
+
+    #[test]
+    fn unknown_font_falls_back_to_default_and_records_warning() {
+        let reg = FontRegistry::new();
+        let (default_font, default_hash) = reg.get_font("default");
+        let (fallback_font, fallback_hash, is_fallback) = reg.get_font_with_status("non-existent-font-1234");
+        assert_eq!(default_hash, fallback_hash);
+        assert!(is_fallback);
+        assert_eq!(default_font.glyph_count(), fallback_font.glyph_count());
+
+        let warnings = reg.get_missing_font_warnings();
+        assert_eq!(warnings.len(), 1);
+        assert!(warnings[0].contains("non-existent-font-1234"));
+    }
+
+    #[test]
+    fn register_custom_font() {
+        let reg = FontRegistry::new();
+        let hash = reg.register_font("inconsolata-custom", DEFAULT_FONT_BYTES).unwrap();
+        assert!(reg.has_font("inconsolata-custom"));
+        let (_, fetched_hash, is_fallback) = reg.get_font_with_status("inconsolata-custom");
+        assert_eq!(hash, fetched_hash);
+        assert!(!is_fallback);
+    }
+
+    #[test]
+    fn strict_lookup_rejects_unregistered_font() {
+        let reg = FontRegistry::new();
+        let error = reg.require_font("missing-desktop-font").unwrap_err();
+        assert!(error.contains("not registered"));
+    }
+
+    #[test]
+    fn global_font_registry_is_singleton() {
+        let r1 = global_font_registry() as *const _;
+        let r2 = global_font_registry() as *const _;
+        assert_eq!(r1, r2);
+    }
+}