Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
fix: preserve layout zoom framing and camera roundness
EtienneLescot06bd7f2e7756
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rsindex 258169996..e7410ad55 100644--- a/crates/compositor/src/frame_geometry.rs+++ b/crates/compositor/src/frame_geometry.rs@@ -3366,7 +3366,16 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {// ratio de boîte se lit sur `s_base` : `remap_box` met les deux axes à la même// échelle, donc la boîte finale a le même ratio et le cover ne dépend pas d'elle// (ce qui casserait la circularité coupe → boîte → coupe).- let screen_cover = sampled_layout.as_ref().map(|s| s.layout.screen_cover)+ // A zoom already running inside a block keeps that viewport until it settles.+ // Releasing its clip halfway into PiP would inflate the frame and then shrink it+ // during the same zoom-out. This is derived from time, so seeks and exports agree.+ let keep_screen_clip = zoom_strength > 0.0 && sampled_layout.as_ref()+ .and_then(|s| s.keep_screen_clip_from_sec)+ .is_some_and(|from| crate::regions::zoom_continues_since(zoom_regions, from, source_t, &clock));+ let keep_screen_clip_prev = zoom_strength_prev > 0.0 && previous_layout.as_ref()+ .and_then(|s| s.keep_screen_clip_from_sec)+ .is_some_and(|from| crate::regions::zoom_continues_since(zoom_regions, from, source_t_prev, &clock));+ let screen_cover = keep_screen_clip || sampled_layout.as_ref().map(|s| s.layout.screen_cover).unwrap_or_else(|| scene.map(|s| s.layout.screen_cover).unwrap_or(false));let cover_box_ar = screen_cover.then_some((s_base[2] * rw) / (s_base[3] * rh).max(0.0001));// Remplissage du format (`screen_follow`) : la fenêtre du cover suit le curseur lissé,@@ -3376,8 +3385,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {let (x, y) = cursor.filter(|_| follow)?.follow_at(t)?;Some([x * u_max, y * v_max])};- let previous_cover_box_ar = previous_layout.as_ref()- .map(|sample| sample.layout.screen_cover).unwrap_or(screen_cover)+ let previous_cover_box_ar = (keep_screen_clip_prev || previous_layout.as_ref()+ .map(|sample| sample.layout.screen_cover).unwrap_or(screen_cover)).then_some((s_base_prev[2] * rw) / (s_base_prev[3] * rh).max(0.0001));let cover_for = |uv: [f32; 4], at: Option<[f32; 2]>, box_ar: Option<f32>| -> [f32; 4] {match (box_ar, at) {@@ -3602,7 +3611,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {// Le remplissage incliné n'a pas de masque : sa boîte est le slot, et la carte penche entière.let screen_mask = (screen_cover && !fill_tilt).then(|| {let slot_px = [s_base[2] * rw, s_base[3] * rh];- let cover_mix = sampled_layout.as_ref().map(|s| s.screen_cover_mix).unwrap_or(1.0);+ let cover_mix = if keep_screen_clip { 1.0 }+ else { sampled_layout.as_ref().map(|s| s.screen_cover_mix).unwrap_or(1.0) };let slot_radius = screen_corner_radius_px(outer_radius_of(slot_px), slot_px);ScreenMask {// A free PiP has no clipping; its equivalent mask is the zoomed box.@@ -4854,7 +4864,8 @@ mod tests {webcam_rect: camera, screen_radius_frac: None, webcam_radius_frac: Some(0.0),webcam_shape: Some("rectangle".to_owned()), screen_cover: false,},- webcam_reactive_zoom: false, from_layout: None, from_preset: None, from_webcam_reactive_zoom: None, transition_start_sec: start, transition_sec: 0.0,+ webcam_reactive_zoom: false, from_layout: None, from_preset: None, from_webcam_reactive_zoom: None,+ keep_screen_clip_from_sec: None, transition_start_sec: start, transition_sec: 0.0,}}@@ -4977,6 +4988,90 @@ mod tests {assert_ne!(g.w_dst, g.w_dst_prev, "an animated camera keeps its motion trail");}+ #[test]+ fn layout_animation_does_not_puff_the_footage_during_an_existing_zoom() {+ use crate::scene::SceneRect;+ let mut scene = golden_scene();+ scene.effects.frame = crate::scene::SceneFrame::Phone;+ scene.crop_by_clip = vec![None];+ let mut zoom = zoomed_golden_scene().zoom_regions.remove(0);+ zoom.start_sec = 0.963;+ zoom.end_sec = 1.301;+ zoom.scale = 1.8;+ let mut later_zoom = zoom.clone();+ later_zoom.start_sec = 5.0;+ later_zoom.end_sec = 6.0;+ scene.zoom_regions = vec![zoom, later_zoom];+ let screen = SceneRect { x: 0.114792, y: 0.077604, width: 0.770416, height: 0.292708 };+ let mut block = layout_region("vertical-stack", 0.0, 1.129, None);+ block.layout.screen_rect = screen;+ block.layout.screen_cover = true;+ let mut pip = layout_region("picture-in-picture", 1.129, 2.163, None);+ pip.layout.screen_rect = SceneRect { y: 0.353646, ..screen };+ pip.from_layout = Some(block.layout.clone());+ pip.transition_sec = 0.2;+ pip.keep_screen_clip_from_sec = Some(1.129);+ let mut no_camera = layout_region("no-webcam", 2.163, 10.0, None);+ no_camera.layout.screen_rect = pip.layout.screen_rect;+ no_camera.from_layout = Some(pip.layout.clone());+ no_camera.transition_sec = 0.1345;+ no_camera.keep_screen_clip_from_sec = Some(1.129);+ scene.layout_regions = vec![block, pip, no_camera];+ let cfg = crate::config::all().pop().expect("compositor config");+ let sample = |t| {+ let mut input = golden_input(&scene, &cfg);+ input.render_px = [1298.0, 1920.0];+ input.timeline_t_override = Some(t);+ plan_frame(&input)+ };+ // Same footage size at both endpoints: moving from top to centre must not inflate it.+ for frame in 0..=180 {+ let t = 1.129 + frame as f32 / 120.0;+ let g = sample(t);+ assert!((g.frame_box()[2] - screen.width).abs() < 0.0001,+ "at {t}: the footage grew to {} instead of {}", g.frame_box()[2], screen.width);+ assert!((g.frame_box()[3] - screen.height).abs() < 0.0001,+ "at {t}: the footage height pulsed");+ }+ assert!(sample(1.25).s_dst[2] > screen.width + 0.1, "the existing zoom still runs inside");+ let next = sample(5.5);+ assert!(next.screen_mask.is_none(), "a later independent PiP zoom must stay free");+ assert!(next.s_dst[2] > screen.width + 0.1);+ }++ #[test]+ fn layout_animation_preserves_camera_roundness_while_it_disappears() {+ use crate::scene::SceneRect;+ let cfg = crate::config::all().pop().expect("compositor config");+ for radius in [0.0, 0.06, 0.3, 0.5] {+ for appearing in [false, true] {+ let mut scene = golden_scene();+ let mut camera = layout_region("picture-in-picture", 0.0, 3.0,+ Some(SceneRect { x: 0.7, y: 0.6, width: 0.2, height: 0.2 * 16.0 / 9.0 }));+ camera.layout.webcam_radius_frac = Some(radius);+ let mut hidden = layout_region("no-webcam", 0.0, 3.0, None);+ hidden.layout.webcam_radius_frac = None;+ let (source, mut target) = if appearing { (hidden, camera) } else { (camera, hidden) };+ target.start_sec = 3.0;+ target.end_sec = 10.0;+ target.transition_start_sec = 3.0;+ target.transition_sec = 0.2;+ target.from_layout = Some(source.layout.clone());+ scene.layout_regions = vec![source, target];+ for progress in [0.05, 0.25, 0.5, 0.75, 0.95] {+ let mut input = golden_input(&scene, &cfg);+ input.render_px = [1920.0, 1080.0];+ input.timeline_t_override = Some(3.0 + 0.2 * progress);+ let g = plan_frame(&input);+ let side = (g.w_dst[2] * 1920.0).min(g.w_dst[3] * 1080.0);+ assert!(side > 0.0);+ assert!((g.w_radius / side - radius).abs() < 0.0001,+ "roundness {radius}, appearing {appearing}, progress {progress}: got {}", g.w_radius / side);+ }+ }+ }+ }+#[test]fn every_layout_pair_has_continuous_footage_at_both_transition_edges() {use crate::scene::{SceneFrame, SceneRect};diff --git a/crates/compositor/src/regions.rs b/crates/compositor/src/regions.rsindex c4791cdec..a923dde78 100644--- a/crates/compositor/src/regions.rs+++ b/crates/compositor/src/regions.rs@@ -835,6 +835,37 @@ fn connected_pairs(pairs}+/// Whether the same uninterrupted zoom is still running after `since` (source time).+/// Uses the zoom sampler's envelope duration, screen clock and connected-pan graph.+/// Once the image settles, a later independent zoom must not inherit a former layout's clip.+pub fn zoom_continues_since(+ regions: &[SceneZoomRegion],+ since: f32,+ t: f32,+ clock: &ScreenClock,+) -> bool {+ if regions.is_empty() || t < since { return false; }+ let (since, t) = (clock.at(since), clock.at(t));+ let mut spans: Vec<(f32, f32)> = regions.iter().map(|r| {+ let window = if r.under_trim { 0.0 } else { zoom_transition_s(r.scale) };+ (clock.at(r.start_sec as f32) - window, clock.at(r.end_sec as f32) + window)+ }).collect();+ spans.extend(connected_pairs(regions, clock).into_iter().map(|(_, ni, start, end)|+ (start, end.max(clock.at(regions[ni].start_sec as f32)))));+ spans.sort_by(|a, b| a.0.total_cmp(&b.0));+ let mut covered_to: Option<f32> = None;+ for (start, end) in spans {+ match covered_to {+ Some(until) if start > until => return false,+ Some(until) => covered_to = Some(until.max(end)),+ None if start < since && since < end => covered_to = Some(end),+ None => continue,+ }+ if covered_to.is_some_and(|until| t < until) { return true; }+ }+ false+}+/// `zoom_state_in` sans speed region ni piste pour l'orbite : ce que les tests comparent.#[cfg(test)]pub fn zoom_state_at(@@ -1703,6 +1734,53 @@ mod zoom_focus_tests {}}+ #[test]+ fn layout_zoom_continuity_stops_before_a_later_independent_zoom() {+ let first = region(1.8, 0.5);+ let mut later = region(1.8, 0.5);+ later.start_sec = 14.0;+ later.end_sec = 16.0;+ let window = zoom_transition_s(first.scale);+ let regions = [first, later];+ let clock = ScreenClock::default();+ assert!(zoom_continues_since(®ions, 4.0, 8.0 + window * 0.9, &clock));+ assert!(!zoom_continues_since(®ions, 4.0, 8.0 + window, &clock));+ assert!(!zoom_continues_since(®ions, 4.0, 15.0, &clock));+ assert!(!zoom_continues_since(®ions, 4.0, 3.0, &clock));+ assert!(!zoom_continues_since(®ions, 0.0, 4.0, &clock));+ }++ #[test]+ fn layout_zoom_continuity_includes_the_connected_pan_and_hold() {+ let mut first = region(1.25, 0.5);+ first.end_sec = 3.0;+ let mut next = region(1.25, 0.7);+ next.start_sec = 4.49;+ next.end_sec = 6.0;+ let regions = [first, next];+ let clock = ScreenClock::default();+ // The independent envelopes leave a hole; the connected pan fills it.+ let middle = 3.745;+ assert_eq!(zoom_region_strength(®ions[0], middle, &clock), 0.0);+ assert_eq!(zoom_region_strength(®ions[1], middle, &clock), 0.0);+ assert!(zoom_state_at(®ions, middle, None).strength > 0.0);+ assert!(zoom_continues_since(®ions, 2.5, middle, &clock));+ assert!(zoom_continues_since(®ions, 2.5, 6.2, &clock));+ }++ #[test]+ fn layout_zoom_continuity_uses_the_same_speed_clock_and_trim_gate() {+ let zoom = region(1.8, 0.5);+ let window = zoom_transition_s(zoom.scale);+ let speeds = [SceneSpeedRegion { start_sec: 0.0, end_sec: 30.0, speed: 2.0, clip_index: Some(0) }];+ let clock = ScreenClock::new(&speeds, 0);+ assert!(zoom_continues_since(&[zoom.clone()], 4.0, 8.0 + window * 1.5, &clock));+ assert!(!zoom_continues_since(&[zoom.clone()], 4.0, 8.0 + window * 2.0 + 0.001, &clock));+ let trimmed = SceneZoomRegion { under_trim: true, ..zoom };+ assert!(zoom_continues_since(&[trimmed.clone()], 4.0, 7.99, &clock));+ assert!(!zoom_continues_since(&[trimmed], 4.0, 8.01, &clock));+ }+/// Le focus automatique ne « perd » jamais la piste : hors de ses bornes, il tient la/// dernière (ou la première) position suivie au lieu de retomber sur le point statique de la/// région. Sans ça, le plan net sauterait d'un bout de l'écran à l'autre à la fin de ladiff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rsindex a4f190334..2a479c8dd 100644--- a/crates/compositor/src/scene.rs+++ b/crates/compositor/src/scene.rs@@ -175,6 +175,9 @@ pub struct SceneLayoutRegion {pub from_preset: Option<String>,#[serde(default)]pub from_webcam_reactive_zoom: Option<bool>,+ /// Last contained-layout exit in source time. A zoom crossing it keeps its viewport.+ #[serde(default)]+ pub keep_screen_clip_from_sec: Option<f32>,pub transition_start_sec: f32,pub transition_sec: f32,}@@ -188,6 +191,7 @@ pub struct SampledLayout<'a> {pub screen_cover_mix: f32,pub webcam_reactive_zoom: f32,pub webcam_shadow: f32,+ pub keep_screen_clip_from_sec: Option<f32>,}impl SceneLayoutRegion {@@ -225,13 +229,20 @@ impl SceneLayoutRegion {// Keep the crop policy through the morph. Its mask is blended separately;// switching the flag at the boundary exposes the entire zoomed footage.layout.screen_cover = from.screen_cover || layout.screen_cover;- layout.webcam_radius_frac = Some(mix(from.webcam_radius_frac.unwrap_or(0.0),- layout.webcam_radius_frac.unwrap_or(0.0)));+ // A missing camera is a scaled-down endpoint of the visible one, not a+ // square mask. Keep its relative roundness while its rectangle collapses.+ layout.webcam_radius_frac = match (from.webcam_rect, self.layout.webcam_rect) {+ (Some(_), None) => from.webcam_radius_frac,+ (None, Some(_)) => self.layout.webcam_radius_frac,+ _ => Some(mix(from.webcam_radius_frac.unwrap_or(0.0),+ layout.webcam_radius_frac.unwrap_or(0.0))),+ };layout.webcam_shape = Some("rectangle".to_owned());}}SampledLayout { preset: &self.preset, layout, from_layout: self.from_layout.as_ref(),hard_cut: self.from_layout.is_none() || self.transition_sec <= 0.0,+ keep_screen_clip_from_sec: self.keep_screen_clip_from_sec,progress, screen_cover_mix, webcam_reactive_zoom: reactive, webcam_shadow }}}diff --git a/src/lib/compositeLayout.test.ts b/src/lib/compositeLayout.test.tsindex 45bbe26ca..0393eee93 100644--- a/src/lib/compositeLayout.test.ts+++ b/src/lib/compositeLayout.test.ts@@ -791,6 +791,20 @@ describe("interpolateCompositeLayout", () => {expect(interpolateCompositeLayout(pip, screenOnly, 0.999).webcamRect?.width).toBeGreaterThan(0);expect(interpolateCompositeLayout(screenOnly, screenOnly, 0.5).webcamRect).toBeNull();});++ it("preserves the camera's relative corner radius throughout appearance and disappearance", () => {+ for (const progress of [0.05, 0.25, 0.5, 0.75, 0.95]) {+ for (const [from, to] of [+ [pip, screenOnly],+ [screenOnly, pip],+ ]) {+ const camera = interpolateCompositeLayout(from, to, progress).webcamRect;+ expect(camera).not.toBeNull();+ if (camera)+ expect(camera.borderRadius / Math.min(camera.width, camera.height)).toBeCloseTo(0.5);+ }+ }+ });});describe("computeCameraFullscreenRect", () => {diff --git a/src/native/layoutScene.test.ts b/src/native/layoutScene.test.tsindex cc76721f1..91f621d52 100644--- a/src/native/layoutScene.test.ts+++ b/src/native/layoutScene.test.ts@@ -43,6 +43,54 @@ function footage() {}describe("layout scene consumed by preview, MP4 and GIF", () => {+ it("carries the last contained exit across free passages even when a trim hides it", () => {+ const base = footage();+ base.legacyEditor = { webcamLayoutPreset: "vertical-stack" };+ const doc = addLayoutChange(addLayoutChange(base, 2, "picture-in-picture"), 4, "no-webcam");+ const regions = buildSceneDescription(doc).layoutRegions;+ expect(regions?.map((r) => r.keepScreenClipFromSec)).toEqual([undefined, 22, 22]);+ doc.timeline.trimRanges = [+ {+ id: "before",+ clipId: "clip",+ assetId: "asset",+ startSec: 20,+ endSec: 24.5,+ origin: "user",+ reason: "test",+ },+ ];+ const visible = buildSceneDescription(doc).layoutRegions?.find((r) => r.preset === "no-webcam");+ expect(visible?.startSec).toBe(24.5);+ expect(visible?.keepScreenClipFromSec).toBe(22);+ });++ it("does not inherit another clip's contained-layout history", () => {+ const base = footage();+ base.timeline.clips.push({+ ...base.timeline.clips[0],+ id: "second",+ timelineStartSec: 10,+ timelineEndSec: 20,+ });+ const doc = addLayoutChange(+ addLayoutChange(base, 2, "vertical-stack"),+ 6,+ "picture-in-picture",+ );+ const scene = buildSceneDescription(doc);+ expect(scene.layoutRegions?.filter((r) => r.clipIndex === 1)).toHaveLength(1);+ expect(+ scene.layoutRegions+ ?.filter((r) => r.clipIndex === 1)+ .every((r) => r.keepScreenClipFromSec === undefined),+ ).toBe(true);+ expect(+ scene.layoutRegions?.find((r) => r.clipIndex === 0 && r.startSec === 26)+ ?.keepScreenClipFromSec,+ ).toBe(26);+ });+it("projects passages into source time with full camera and no-webcam geometry", () => {const doc = addLayoutChange(addLayoutChange(footage(), 2, "camera-only"), 4, "no-webcam");const scene = buildSceneDescription(doc);diff --git a/src/native/sceneDescription.ts b/src/native/sceneDescription.tsindex f8d73df8e..3eba47b44 100644--- a/src/native/sceneDescription.ts+++ b/src/native/sceneDescription.ts@@ -57,6 +57,7 @@ import {} from "@/lib/ai-edition/timeline/zoom-scale";import {computeCompositeLayout,+ isWebcamBlockLayout,paddedContentSize,type RenderRect,resolveWebcamLayoutPreset,@@ -418,6 +419,8 @@ export interface SceneLayoutRegion {fromLayout?: ResolvedClipLayout;fromPreset?: LayoutPreset;fromWebcamReactiveZoom?: boolean;+ /** Last contained-layout exit in source seconds. An ongoing zoom keeps that viewport until it settles. */+ keepScreenClipFromSec?: number;/** Original passage start in source seconds; trimming must not restart its animation. */transitionStartSec: number;/** Duration in source seconds, or 0 without fromLayout (including legacy-camera neighbours). */@@ -1372,6 +1375,22 @@ export function buildSceneDescription();const fromLayout =!region.legacyCamera && previous && !previous.legacyCamera ? resolve(previous.preset) : null;+ // Carry this history through later free passages and trim projections. Native can+ // then keep a zoom already in flight inside its viewport, without constraining a new one.+ const keepScreenClipFromSec = storedLayouts.reduce<number | undefined>((last, candidate) => {+ if (+ candidate.clipId !== region.clipId ||+ candidate.sourceEndSec === undefined ||+ region.sourceStartSec === undefined ||+ candidate.sourceEndSec > region.sourceStartSec + 0.0001 ||+ !(+ formatFill ||+ (hasCamera && isWebcamBlockLayout(candidate.legacyCamera?.basePreset ?? candidate.preset))+ )+ )+ return last;+ return Math.max(last ?? -Infinity, candidate.sourceEndSec);+ }, undefined);return [{clipIndex: region.clipIndex,@@ -1380,6 +1399,7 @@ export function buildSceneDescription(preset,layout,webcamReactiveZoom: resolveWebcamReactiveZoom(preset, settings.webcamReactiveZoom),+ ...(keepScreenClipFromSec === undefined ? {} : { keepScreenClipFromSec }),...(fromLayout && previous? {fromLayout,diff --git a/technical-documentation/architecture/timeline-model.md b/technical-documentation/architecture/timeline-model.mdindex b626577f6..d72044928 100644--- a/technical-documentation/architecture/timeline-model.md+++ b/technical-documentation/architecture/timeline-model.md@@ -357,10 +357,21 @@ It never falls back to a whole-video preset write when no passage is active.`buildSceneDescription` resolves both endpoints of a change per source clip. Native`SceneLayoutRegion::sample` drives rectangle geometry, the screen's clipping weight,reactive camera size and camera shadow with one eased progress value. The clipping-box grows continuously from a fixed block slot to the free zoomed PiP box (and back).-Corner interpolation resolves each endpoint's real fallback radius. Changing a boolean-crop policy at a boundary would expose the enlarged footage abruptly; it must never-substitute for interpolating the visible crop. Preview, MP4 and GIF share this planner.+box interpolates between the two layout slots. When a zoom is already running inside+a contained layout, it keeps that viewport until the uninterrupted zoom settles;+otherwise releasing the clip during a top/bottom → PiP change would inflate the+footage and then shrink it again. Later independent PiP zooms retain their overflow.+The derived scene carries the last contained-layout exit per original source clip,+including through trims and subsequent free passages. Native checks continuity against+the zoom sampler's screen clock, envelopes and connected-pan graph, so seeking does+not require playback history or another authored document field.++Corner interpolation resolves each endpoint's real fallback radius. A camera appearing+or disappearing retains its visible endpoint's relative corner radius as its rectangle+scales; interpolating that fraction toward zero would square its corners before it+vanishes. Changing a boolean crop policy at a boundary would expose enlarged footage+abruptly; it must never substitute for interpolating the visible crop. Preview, MP4 and+GIF share this planner.The deterministic workbench includes layout anchors and playability, counts a uniformglobal layout change even without stored fragments, and checks tool-returned segmentsdiff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.mdindex cc45f4d8c..590c6867f 100644--- a/technical-documentation/testing/manual-e2e-checklist.md+++ b/technical-documentation/testing/manual-e2e-checklist.md@@ -1004,3 +1004,4 @@ These checks are the human slice: an agent cannot click Apple's picker (see abov| 2026-10-23 | `fix/mac-mic-silent-with-system-audio` on `main` @ `264975d`, dev build (`npm run dev`), capture helper built locally with Xcode 27 and copied from `out/Products/Release` by hand | macOS 26.6.2 (25G83), MacBook Pro M2 Pro; built-in microphone and a USB Audio CODEC (08bb:2902) | **Partial: fix slice only, pass** | #1173, Apple's picker, system audio on, output device idle (after `sudo killall coreaudiod`, or checked idle). Before the fix: the microphone delivered nothing until another app played a sound, 56 s (built-in) and 14 s (USB) into the take; without system audio it started at 0.17 s. With the tap merely started after the stream, four takes (built-in twice, USB twice) recorded the microphone from 0.17–0.18 s, but only 12–30 ms ahead of the tap. With this branch's version, the tap waiting for the first microphone buffer: one USB take recorded the microphone from 0.18 s and the tap started 27 ms after it; one take with the microphone off. In both, a sound played mid-take was in system audio. Measured with temporary per-source buffer counters in the helper, not shipped. **Not covered:** this branch's version with the built-in microphone, a legacy-picker take, macOS 15, an Intel Mac, a microphone that never delivers (the 1 s fallback), pause before the first microphone buffer, a CI-built artifact. || 2026-10-27 | Dev v2.1.2, `codex/timeline-dispositions` on `main` @ `27d9be27b` + local layouts/schema-v9 changes; Windows compositor rebuilt from this tree; complete v2.1.2 native binary directory copied and hash-checked before the rebuild | Windows 11, D3D11 / NVENC | **Partial — export slice passed; desktop UI interrupted** | Synthetic screen + linked webcam, shared native scene exported to MP4 (300 frames at 30 fps) and GIF (100 frames at 10 fps). Side-by-side and top/bottom keep zoomed footage inside their slots (0 blue source pixels outside either slot); PiP restores overflow. For top/bottom → PiP with 2.2× zoom, the MP4 has identical blue areas before/at the transition start (66,612 pixels) and at/after its end (483,645 pixels), with progressive intermediate sizes. Native geometry tests cover all 20 ordered layout pairs, both animation edges, zoom 1×/2×, frames none/window/laptop, crop, camera, corners and shadow. 472 native tests passed; the one excluded playback-at-end test also fails on pristine `27d9be27b` on this hardware. Desktop computer-use was stopped by the user with Escape, so GUI preview/playback, actual device-frame controls, timeline mouse/keyboard editing and persistence were **not visually verified** after the port. The app was relaunched with the rebuilt addon; the maintainer subsequently tested it and reported that the feature works. Final pre-PR JavaScript suite: 5,058 passed, 5 skipped; app/test typechecks passed. **Skipped:** real capture/webcam/tray, tilted/3D transition pixel exports, the remaining checklist, macOS/Linux runtime verification. This is not release-promotion QA. || 2026-10-27 | Dev v2.1.2, `codex/timeline-dispositions`, review follow-up to `5b76530fb`; MSVC Rust test binary rebuilt from this tree | Windows 11 | **Partial — automated regression slice only** | PR #1404 review fixes: 10 native layout tests passed, including new hard-cut motion-blur isolation and preservation of positive-duration animation trails. React regressions cover selecting only the last passage at/after timeline end and closing/clearing the layout picker in media mode, without a document, or without clips. Agent tests reject no-op layout writes; workbench verifies reports only when no later mutation follows. Full JavaScript suite: 5,069 passed, 5 skipped; 19 targeted workbench tests and app/test/workbench typechecks pass. **Skipped:** desktop computer-use was not resumed after the user's earlier Escape; no fresh GUI preview, export pixel, capture, device, tray, macOS/Linux runtime or full checklist pass. The running app's native addon was not replaced during this review follow-up. |+| 2026-10-27 | Dev v2.1.2, `codex/timeline-dispositions` @ `ee1eeb9f2` + zoom-framing/camera-roundness fix; Windows compositor rebuilt from this tree | Windows 11, D3D11 / NVENC | **Partial — native export regression slice passed** | Recreated the latest saved project’s 1298×1920 phone-frame scene with synthetic screen/camera media: top/bottom → PiP at 1.129 s during a 1.8× zoom, then screen-only at 2.163 s. Measured 12 frames from the native 146-frame, 60 fps MP4: footage width stays 994 px throughout (before: grew from 994 to 1298 px and returned). During camera disappearance, rounded-mask fill stays 88.3–89.9% (before: 97.5% at 2.23 s, visibly squaring); camera vanishes at 2.30 s. Native regressions also cover appearance, multiple radii, later independent PiP zoom overflow, connected pans, speed and trim gates; scene tests cover trimmed history and clip isolation. Full JavaScript suite: 5,082 passed, 5 skipped; 479 native tests passed, with the same playback-at-end baseline failure excluded after its earlier reproduction on pristine `27d9be27b`. **Skipped:** desktop computer-use was not resumed after the user’s earlier Escape; GUI preview/playback, real capture/webcam/tray, tilted/3D pixel exports, macOS/Linux runtime and the remainder of the release checklist. The export uses the shared preview/export geometry planner; this is not release-promotion QA. |