fix(preview, properties, export): timeline-zero effect cache, text-template properties tabs, and audio speed export filter chain

src-tauri/src/commands/export/audio_filter.rs

@@ -48,6 +48,20 @@ pub(crate) async fn has_audio_stream(path: &str) -> bool {
 
 
 
+pub(crate) fn build_atempo_filter_chain(mut speed: f64) -> String {
+    let mut filters = Vec::new();
+    while speed > 2.0 {
+        filters.push("atempo=2.0".to_string());
+        speed /= 2.0;
+    }
+    while speed < 0.5 {
+        filters.push("atempo=0.5".to_string());
+        speed /= 0.5;
+    }
+    filters.push(format!("atempo={:.4}", speed));
+    filters.join(",")
+}
+
 pub(crate) fn build_export_audio_filter_complex(
     valid_audio_clips: &[ExportAudioClip],
     total_duration: f64,
@@ -71,7 +85,10 @@ pub(crate) fn build_export_audio_filter_complex(
     for (idx, clip) in valid_audio_clips.iter().enumerate() {
         let input_idx = idx + 1; // input 0 is pipe:0 (video)
         let delay_ms = (clip.start_time * 1000.0) as i64;
-        let end_time = clip.trim_in + clip.duration;
+        let speed = clip.speed.unwrap_or(1.0).max(0.01);
+        let preserve_pitch = clip.preserve_pitch.unwrap_or(true);
+        let source_duration = clip.duration * speed;
+        let end_time = clip.trim_in + source_duration;
 
         let fade_in = clip.fade_in.unwrap_or(0.0).max(0.0).min(clip.duration);
         let fade_out = clip.fade_out.unwrap_or(0.0).max(0.0).min(clip.duration);
@@ -83,6 +100,14 @@ pub(crate) fn build_export_audio_filter_complex(
             input_idx, clip.trim_in, end_time
         );
 
+        if (speed - 1.0).abs() > 0.001 {
+            if preserve_pitch {
+                chain.push_str(&format!(",{}", build_atempo_filter_chain(speed)));
+            } else {
+                chain.push_str(&format!(",asetrate={:.0},aresample=48000", 48000.0 * speed));
+            }
+        }
+
         let in_curve = match clip.fade_in_curve.as_deref() {
             Some("exponential") => ":curve=exp",
             Some("logarithmic") => ":curve=log",

src-tauri/src/commands/export/tests.rs

@@ -37,6 +37,8 @@ mod tests {
                 duration: 5.0,
                 volume: 1.0,
                 trim_in: 0.0,
+                speed: None,
+                preserve_pitch: None,
                 fade_in: None,
                 fade_out: None,
                 fade_in_curve: None,
@@ -57,6 +59,8 @@ mod tests {
                 duration: 4.0,
                 volume: 0.8,
                 trim_in: 0.0,
+                speed: None,
+                preserve_pitch: None,
                 fade_in: None,
                 fade_out: None,
                 fade_in_curve: None,
@@ -87,6 +91,51 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_export_audio_speed_filter_chain() {
+        assert_eq!(
+            build_atempo_filter_chain(2.0),
+            "atempo=2.0000"
+        );
+        assert_eq!(
+            build_atempo_filter_chain(4.0),
+            "atempo=2.0,atempo=2.0000"
+        );
+        assert_eq!(
+            build_atempo_filter_chain(0.25),
+            "atempo=0.5,atempo=0.5000"
+        );
+
+        let clip_2x = ExportAudioClip {
+            path: "/path/to/voice.mp3".to_string(),
+            start_time: 1.0,
+            duration: 5.0,
+            trim_in: 0.0,
+            speed: Some(2.0),
+            preserve_pitch: Some(true),
+            volume: 1.0,
+            fade_in: None,
+            fade_out: None,
+            fade_in_curve: None,
+            fade_out_curve: None,
+            eq_low: None,
+            eq_mid: None,
+            eq_high: None,
+            pan: None,
+            noise_suppression: None,
+            volume_keyframes: None,
+            channel_map: None,
+            channel_mode: None,
+            downmix: None,
+        };
+
+        let filter = build_export_audio_filter_complex(&[clip_2x], 10.0);
+        // atrim must cover 5.0 * 2.0 = 10.0 seconds of source audio
+        assert!(filter.contains("atrim=start=0.000:end=10.000"));
+        // atempo filter must be included
+        assert!(filter.contains("atempo=2.0000"));
+    }
+
     fn base_test_config() -> ExportConfig {
         ExportConfig {
             output_path: "/tmp/test_export.mp4".to_string(),
@@ -184,6 +233,8 @@ mod tests {
             start_time: 0.0,
             duration: -1.0,
             trim_in: 0.0,
+            speed: None,
+            preserve_pitch: None,
             volume: 1.0,
             fade_in: None,
             fade_out: None,
@@ -209,6 +260,8 @@ mod tests {
             start_time: -0.5,
             duration: 1.0,
             trim_in: 0.0,
+            speed: None,
+            preserve_pitch: None,
             volume: 1.0,
             fade_in: None,
             fade_out: None,
@@ -234,6 +287,8 @@ mod tests {
             start_time: 0.0,
             duration: 1.0,
             trim_in: 0.0,
+            speed: None,
+            preserve_pitch: None,
             volume: 1.0,
             fade_in: None,
             fade_out: None,

src-tauri/src/commands/export/types.rs

@@ -68,6 +68,12 @@ pub struct ExportAudioClip {
     /// Trim in offset in seconds inside the source media file
     pub trim_in: f64,
 
+    /// Speed multiplier (e.g. 1.0, 2.0, 0.5)
+    pub speed: Option<f64>,
+
+    /// Whether to preserve pitch during speed change (default true)
+    pub preserve_pitch: Option<bool>,
+
     /// Volume multiplier (0.0-1.0)
     /// This prevents precision loss during serialization round-trips
     pub volume: f64,

src-tauri/src/commands/native_playback/render_session.rs

@@ -676,8 +676,22 @@ impl NativeRenderSession {
                             .iter()
                             .find(|r| r.layer_id.as_deref() == Some(lid))
                             .cloned()
+                            .or_else(|| {
+                                request
+                                    .project
+                                    .raster_layers
+                                    .iter()
+                                    .find(|r| !r.asset_id.is_empty() && r.asset_id == update.asset_id)
+                                    .cloned()
+                            })
                     } else {
-                        request.project.raster_layers.get(i).cloned()
+                        request
+                            .project
+                            .raster_layers
+                            .iter()
+                            .find(|r| !r.asset_id.is_empty() && r.asset_id == update.asset_id)
+                            .cloned()
+                            .or_else(|| request.project.raster_layers.get(i).cloned())
                     };
                     if let Some(mut layer) = existing {
                         if let Some(layer_id) = &update.layer_id {
@@ -724,7 +738,7 @@ impl NativeRenderSession {
                                 .unwrap_or_else(|| "normal".to_string()),
                             color_grade: None,
                             is_mask: update.is_mask,
-                            is_text: true,
+                            is_text: update.asset_id.starts_with("native-text:"),
                             is_premultiplied: false,
                         });
                     }

src-tauri/src/commands/native_preview/mod.rs

@@ -2567,10 +2567,11 @@ pub(crate) async fn present_native_frame_internal(
     let queued_key = request
         .decode_cache_key()
         .map_err(|error| error.to_string())?;
+    let has_video_layers = !request.project.video_layers.is_empty();
     let is_playback_mode = request.mode.as_deref() == Some("playback");
     let mut playback_lookahead_miss = false;
     let lookahead_wait_us: u64 = 0;
-    let queued_frame =
+    let queued_frame = if has_video_layers {
         if let Some(queue) = app.try_state::<Arc<tokio::sync::Mutex<NativePreviewFrameQueue>>>() {
             let queue_arc = queue.inner().clone();
             let mut q = queue_arc.lock().await;
@@ -2600,8 +2601,11 @@ pub(crate) async fn present_native_frame_internal(
             }
         } else {
             None
-        };
-    if is_playback_mode {
+        }
+    } else {
+        None
+    };
+    if is_playback_mode && has_video_layers {
         record_playback_lookahead_outcome(&app, queued_frame.is_some());
     }
     if playback_lookahead_miss {

src/components/editor/__tests__/PropertiesPanelTextAnimation.test.tsx

@@ -93,4 +93,61 @@ describe("PropertiesPanel text clip animation and transform keyframe integration
     expect(screen.getByText("Position")).toBeDefined();
     expect(screen.getByText("Plane rotation")).toBeDefined();
   });
+
+  it("renders sticky duration footer in PropertiesPanel when text clip has an active in-preset", () => {
+    useTimelineStore.setState({
+      clips: [
+        {
+          ...mockTextClip,
+          motion: {
+            inPreset: "anim-in-flip-in",
+            inDuration: 0.6,
+          },
+        },
+      ],
+    });
+
+    render(<PropertiesPanel />);
+
+    // Click "Animation" tab
+    const animationTabButton = screen.getByRole("button", {
+      name: /Animation/i,
+    });
+    fireEvent.click(animationTabButton);
+
+    // Verify the sticky duration control is rendered in the footer
+    expect(screen.getByText("Duration")).toBeDefined();
+    expect(screen.getByText("0.6s")).toBeDefined();
+
+    // Verify stepping duration updates the pill in UI
+    const plusButton = screen.getByRole("button", {
+      name: "Increase duration",
+    });
+    fireEvent.click(plusButton);
+    expect(screen.getByText("0.7s")).toBeDefined();
+  });
+
+  it("hides sticky duration footer when text clip has no active animation preset on selected tab", () => {
+    useTimelineStore.setState({
+      clips: [
+        {
+          ...mockTextClip,
+          motion: {
+            inPreset: "none",
+          },
+        },
+      ],
+    });
+
+    render(<PropertiesPanel />);
+
+    // Click "Animation" tab
+    const animationTabButton = screen.getByRole("button", {
+      name: /Animation/i,
+    });
+    fireEvent.click(animationTabButton);
+
+    // Verify duration is NOT rendered
+    expect(screen.queryByText("Duration")).toBeNull();
+  });
 });