From 742d3d865a787728e4cc6a784155ed1b41e42017 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sat, 3 Oct 2026 21:45:00 +0200
Subject: [PATCH 01/22] feat(wgc): read a list of cameras from the helper
 config

---
 electron/native/wgc-capture/CMakeLists.txt    |  20 +++
 .../native/wgc-capture/src/json_fields.cpp    | 125 ++++++++++++++++++
 electron/native/wgc-capture/src/json_fields.h |  10 ++
 electron/native/wgc-capture/src/main.cpp      | 118 +----------------
 .../native/wgc-capture/src/webcam_config.cpp  |  92 +++++++++++++
 .../native/wgc-capture/src/webcam_config.h    |  17 +++
 .../wgc-capture/src/webcam_config_test.cpp    |  63 +++++++++
 scripts/build-windows-wgc-helper.mjs          |   8 ++
 8 files changed, 336 insertions(+), 117 deletions(-)
 create mode 100644 electron/native/wgc-capture/src/json_fields.cpp
 create mode 100644 electron/native/wgc-capture/src/json_fields.h
 create mode 100644 electron/native/wgc-capture/src/webcam_config.cpp
 create mode 100644 electron/native/wgc-capture/src/webcam_config.h
 create mode 100644 electron/native/wgc-capture/src/webcam_config_test.cpp

diff --git a/electron/native/wgc-capture/CMakeLists.txt b/electron/native/wgc-capture/CMakeLists.txt
index 50466d0d0..84aa89853 100644
--- a/electron/native/wgc-capture/CMakeLists.txt
+++ b/electron/native/wgc-capture/CMakeLists.txt
@@ -44,6 +44,8 @@ add_executable(wgc-capture
   src/realtime_scheduling.h
   src/frame_visibility.cpp
   src/frame_visibility.h
+  src/json_fields.cpp
+  src/json_fields.h
   src/dshow_webcam_capture.cpp
   src/dshow_webcam_capture.h
   src/main.cpp
@@ -60,6 +62,8 @@ add_executable(wgc-capture
   src/webcam_capture.cpp
   src/webcam_format.cpp
   src/webcam_format.h
+  src/webcam_config.cpp
+  src/webcam_config.h
   src/webcam_capture.h
   src/wgc_session.cpp
   src/wgc_session.h
@@ -198,3 +202,19 @@ target_link_libraries(mf_encoder_color_test PRIVATE
   ole32
   propsys
 )
+
+add_executable(webcam_config_test
+  src/json_fields.cpp
+  src/json_fields.h
+  src/webcam_config.cpp
+  src/webcam_config.h
+  src/webcam_config_test.cpp
+)
+
+target_compile_definitions(webcam_config_test PRIVATE
+  NOMINMAX
+  WIN32_LEAN_AND_MEAN
+  _WIN32_WINNT=0x0A00
+)
+
+target_compile_options(webcam_config_test PRIVATE /EHsc /W4 /utf-8)
diff --git a/electron/native/wgc-capture/src/json_fields.cpp b/electron/native/wgc-capture/src/json_fields.cpp
new file mode 100644
index 000000000..e36a43e81
--- /dev/null
+++ b/electron/native/wgc-capture/src/json_fields.cpp
@@ -0,0 +1,125 @@
+#include "json_fields.h"
+
+#include <cctype>
+#include <cstdint>
+
+// Lightweight field lookups over the helper's single JSON argument. They match
+// the first occurrence of a key anywhere in the document.
+
+bool findBool(const std::string& json, const std::string& key, bool fallback) {
+    auto pos = json.find("\"" + key + "\"");
+    if (pos == std::string::npos) {
+        return fallback;
+    }
+    pos = json.find(':', pos);
+    if (pos == std::string::npos) {
+        return fallback;
+    }
+    pos += 1;
+    while (pos < json.size() && std::isspace(static_cast<unsigned char>(json[pos]))) {
+        pos += 1;
+    }
+    if (json.compare(pos, 4, "true") == 0) {
+        return true;
+    }
+    if (json.compare(pos, 5, "false") == 0) {
+        return false;
+    }
+    return fallback;
+}
+
+int64_t findInt64(const std::string& json, const std::string& key, int64_t fallback) {
+    auto pos = json.find("\"" + key + "\"");
+    if (pos == std::string::npos) {
+        return fallback;
+    }
+    pos = json.find(':', pos);
+    if (pos == std::string::npos) {
+        return fallback;
+    }
+    pos += 1;
+    while (pos < json.size() && std::isspace(static_cast<unsigned char>(json[pos]))) {
+        pos += 1;
+    }
+    try {
+        return std::stoll(json.substr(pos));
+    } catch (...) {
+        return fallback;
+    }
+}
+
+int findInt(const std::string& json, const std::string& key, int fallback) {
+    return static_cast<int>(findInt64(json, key, fallback));
+}
+
+double findDouble(const std::string& json, const std::string& key, double fallback) {
+    auto pos = json.find("\"" + key + "\"");
+    if (pos == std::string::npos) {
+        return fallback;
+    }
+    pos = json.find(':', pos);
+    if (pos == std::string::npos) {
+        return fallback;
+    }
+    pos += 1;
+    while (pos < json.size() && std::isspace(static_cast<unsigned char>(json[pos]))) {
+        pos += 1;
+    }
+    try {
+        return std::stod(json.substr(pos));
+    } catch (...) {
+        return fallback;
+    }
+}
+
+std::string findString(const std::string& json, const std::string& key) {
+    auto pos = json.find("\"" + key + "\"");
+    if (pos == std::string::npos) {
+        return {};
+    }
+    pos = json.find(':', pos);
+    if (pos == std::string::npos) {
+        return {};
+    }
+    pos += 1;
+    while (pos < json.size() && std::isspace(static_cast<unsigned char>(json[pos]))) {
+        pos += 1;
+    }
+    if (pos >= json.size() || json[pos] != '"') {
+        return {};
+    }
+    pos += 1;
+
+    std::string result;
+    while (pos < json.size()) {
+        const char c = json[pos++];
+        if (c == '"') {
+            break;
+        }
+        if (c == '\\' && pos < json.size()) {
+            const char escaped = json[pos++];
+            switch (escaped) {
+                case '\\':
+                case '"':
+                case '/':
+                    result.push_back(escaped);
+                    break;
+                case 'n':
+                    result.push_back('\n');
+                    break;
+                case 'r':
+                    result.push_back('\r');
+                    break;
+                case 't':
+                    result.push_back('\t');
+                    break;
+                default:
+                    result.push_back(escaped);
+                    break;
+            }
+            continue;
+        }
+        result.push_back(c);
+    }
+    return result;
+}
diff --git a/electron/native/wgc-capture/src/json_fields.h b/electron/native/wgc-capture/src/json_fields.h
new file mode 100644
index 000000000..0921b3381
--- /dev/null
+++ b/electron/native/wgc-capture/src/json_fields.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+bool findBool(const std::string& json, const std::string& key, bool fallback);
+int64_t findInt64(const std::string& json, const std::string& key, int64_t fallback);
+int findInt(const std::string& json, const std::string& key, int fallback);
+double findDouble(const std::string& json, const std::string& key, double fallback);
+std::string findString(const std::string& json, const std::string& key);
diff --git a/electron/native/wgc-capture/src/main.cpp b/electron/native/wgc-capture/src/main.cpp
index 1bad39699..5ba80cd49 100644
--- a/electron/native/wgc-capture/src/main.cpp
+++ b/electron/native/wgc-capture/src/main.cpp
@@ -8,6 +8,7 @@
 #include "wasapi_loopback_capture.h"
 #include "wasapi_render_keepalive.h"
 #include "frame_visibility.h"
+#include "json_fields.h"
 #include "webcam_capture.h"
 #include "wgc_session.h"
 
@@ -396,123 +397,6 @@ void reportCaptureAdapters(ID3D11Device* device, HMONITOR targetMonitor) {
 }
 
 
-bool findBool(const std::string& json, const std::string& key, bool fallback) {
-    auto pos = json.find("\"" + key + "\"");
-    if (pos == std::string::npos) {
-        return fallback;
-    }
-    pos = json.find(':', pos);
-    if (pos == std::string::npos) {
-        return fallback;
-    }
-    pos += 1;
-    while (pos < json.size() && std::isspace(static_cast<unsigned char>(json[pos]))) {
-        pos += 1;
-    }
-    if (json.compare(pos, 4, "true") == 0) {
-        return true;
-    }
-    if (json.compare(pos, 5, "false") == 0) {
-        return false;
-    }
-    return fallback;
-}
-
-int64_t findInt64(const std::string& json, const std::string& key, int64_t fallback) {
-    auto pos = json.find("\"" + key + "\"");
-    if (pos == std::string::npos) {
-        return fallback;
-    }
-    pos = json.find(':', pos);
-    if (pos == std::string::npos) {
-        return fallback;
-    }
-    pos += 1;
-    while (pos < json.size() && std::isspace(static_cast<unsigned char>(json[pos]))) {
-        pos += 1;
-    }
-    try {
-        return std::stoll(json.substr(pos));
-    } catch (...) {
-        return fallback;
-    }
-}
-
-int findInt(const std::string& json, const std::string& key, int fallback) {
-    return static_cast<int>(findInt64(json, key, fallback));
-}
-
-double findDouble(const std::string& json, const std::string& key, double fallback) {
-    auto pos = json.find("\"" + key + "\"");
-    if (pos == std::string::npos) {
-        return fallback;
-    }
-    pos = json.find(':', pos);
-    if (pos == std::string::npos) {
-        return fallback;
-    }
-    pos += 1;
-    while (pos < json.size() && std::isspace(static_cast<unsigned char>(json[pos]))) {
-        pos += 1;
-    }
-    try {
-        return std::stod(json.substr(pos));
-    } catch (...) {
-        return fallback;
-    }
-}
-
-std::string findString(const std::string& json, const std::string& key) {
-    auto pos = json.find("\"" + key + "\"");
-    if (pos == std::string::npos) {
-        return {};
-    }
-    pos = json.find(':', pos);
-    if (pos == std::string::npos) {
-        return {};
-    }
-    pos += 1;
-    while (pos < json.size() && std::isspace(static_cast<unsigned char>(json[pos]))) {
-        pos += 1;
-    }
-    if (pos >= json.size() || json[pos] != '"') {
-        return {};
-    }
-    pos += 1;
-
-    std::string result;
-    while (pos < json.size()) {
-        const char c = json[pos++];
-        if (c == '"') {
-            break;
-        }
-        if (c == '\\' && pos < json.size()) {
-            const char escaped = json[pos++];
-            switch (escaped) {
-                case '\\':
-                case '"':
-                case '/':
-                    result.push_back(escaped);
-                    break;
-                case 'n':
-                    result.push_back('\n');
-                    break;
-                case 'r':
-                    result.push_back('\r');
-                    break;
-                case 't':
-                    result.push_back('\t');
-                    break;
-                default:
-                    result.push_back(escaped);
-                    break;
-            }
-            continue;
-        }
-        result.push_back(c);
-    }
-    return result;
-}
 
 std::string parseWindowHandleFromSourceId(const std::string& sourceId) {
     constexpr char prefix[] = "window:";
diff --git a/electron/native/wgc-capture/src/webcam_config.cpp b/electron/native/wgc-capture/src/webcam_config.cpp
new file mode 100644
index 000000000..d437b9d26
--- /dev/null
+++ b/electron/native/wgc-capture/src/webcam_config.cpp
@@ -0,0 +1,92 @@
+#include "webcam_config.h"
+
+#include "json_fields.h"
+
+#include <utility>
+
+namespace {
+
+// The find* helpers search the whole document, so each array entry is sliced
+// out first to keep its fields from being confused with the top-level ones.
+std::vector<std::string> splitTopLevelObjects(const std::string& json, const std::string& arrayKey) {
+    std::vector<std::string> objects;
+    size_t pos = json.find("\"" + arrayKey + "\"");
+    if (pos == std::string::npos) {
+        return objects;
+    }
+    pos = json.find('[', pos);
+    if (pos == std::string::npos) {
+        return objects;
+    }
+    ++pos;
+
+    int depth = 0;
+    bool inString = false;
+    size_t objectStart = 0;
+    for (; pos < json.size(); ++pos) {
+        const char c = json[pos];
+        if (inString) {
+            if (c == '\\') {
+                ++pos;
+            } else if (c == '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (c == '"') {
+            inString = true;
+        } else if (c == '{') {
+            if (depth == 0) {
+                objectStart = pos;
+            }
+            ++depth;
+        } else if (c == '}') {
+            if (depth > 0 && --depth == 0) {
+                objects.push_back(json.substr(objectStart, pos - objectStart + 1));
+            }
+        } else if (c == ']' && depth == 0) {
+            break;
+        }
+    }
+    return objects;
+}
+
+}  // namespace
+
+std::vector<WebcamConfig> parseWebcamConfigs(const std::string& json) {
+    std::vector<WebcamConfig> configs;
+    for (const std::string& entry : splitTopLevelObjects(json, "webcams")) {
+        if (configs.size() >= kMaxWebcams) {
+            break;
+        }
+        WebcamConfig config;
+        config.outputPath = findString(entry, "camPath");
+        if (config.outputPath.empty()) {
+            continue;
+        }
+        config.deviceId = findString(entry, "camDeviceId");
+        config.deviceName = findString(entry, "camDeviceName");
+        config.directShowClsid = findString(entry, "camClsid");
+        config.width = findInt(entry, "camWidth", 0);
+        config.height = findInt(entry, "camHeight", 0);
+        config.fps = findInt(entry, "camFps", 0);
+        configs.push_back(std::move(config));
+    }
+    if (!configs.empty() || !findBool(json, "webcamEnabled", false)) {
+        return configs;
+    }
+
+    WebcamConfig legacy;
+    legacy.outputPath = findString(json, "webcamPath");
+    if (legacy.outputPath.empty()) {
+        return configs;
+    }
+    legacy.deviceId = findString(json, "webcamDeviceId");
+    legacy.deviceName = findString(json, "webcamDeviceName");
+    legacy.directShowClsid = findString(json, "webcamDirectShowClsid");
+    legacy.width = findInt(json, "webcamWidth", 0);
+    legacy.height = findInt(json, "webcamHeight", 0);
+    legacy.fps = findInt(json, "webcamFps", 0);
+    configs.push_back(std::move(legacy));
+    return configs;
+}
diff --git a/electron/native/wgc-capture/src/webcam_config.h b/electron/native/wgc-capture/src/webcam_config.h
new file mode 100644
index 000000000..b0c0998ea
--- /dev/null
+++ b/electron/native/wgc-capture/src/webcam_config.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+struct WebcamConfig {
+    std::string deviceId, deviceName, directShowClsid, outputPath;
+    int width = 0, height = 0, fps = 0;
+};
+
+constexpr size_t kMaxWebcams = 4;
+
+// The cameras to record, in order. Reads the `webcams` list when present and
+// non-empty; otherwise the legacy single-camera fields (webcamEnabled, webcamDeviceId,
+// webcamDeviceName, webcamDirectShowClsid, webcamWidth/Height/Fps, webcamPath).
+std::vector<WebcamConfig> parseWebcamConfigs(const std::string& json);
diff --git a/electron/native/wgc-capture/src/webcam_config_test.cpp b/electron/native/wgc-capture/src/webcam_config_test.cpp
new file mode 100644
index 000000000..1696698bf
--- /dev/null
+++ b/electron/native/wgc-capture/src/webcam_config_test.cpp
@@ -0,0 +1,63 @@
+#include "webcam_config.h"
+
+#include <cstdio>
+#include <string>
+
+namespace {
+int failures = 0;
+void expect(bool ok, const char* label) {
+    if (!ok) {
+        std::printf("FAIL %s\n", label);
+        ++failures;
+    }
+}
+}  // namespace
+
+int main() {
+    const std::string legacy =
+        R"({"fps":60,"width":2560,"height":1440,"webcamEnabled":true,"webcamDeviceId":"id1",)"
+        R"("webcamDeviceName":"Cam One","webcamDirectShowClsid":"{A}","webcamWidth":1920,)"
+        R"("webcamHeight":1080,"webcamFps":30,"outputs":{"screenPath":"s.mp4","webcamPath":"w.mp4"}})";
+    auto l = parseWebcamConfigs(legacy);
+    expect(l.size() == 1, "legacy: one camera");
+    expect(l.size() == 1 && l[0].deviceName == "Cam One" && l[0].outputPath == "w.mp4" &&
+               l[0].width == 1920 && l[0].fps == 30,
+           "legacy: fields");
+
+    expect(parseWebcamConfigs(R"({"webcamEnabled":false,"webcamPath":"w.mp4"})").empty(),
+           "legacy disabled: none");
+
+    const std::string list =
+        R"({"fps":60,"width":2560,"webcamEnabled":true,"webcamDeviceName":"Cam One","webcamPath":"w.mp4",)"
+        R"("webcams":[{"camDeviceId":"id1","camDeviceName":"Cam One","camClsid":"{A}","camWidth":1920,)"
+        R"("camHeight":1080,"camFps":30,"camPath":"w.mp4"},)"
+        R"({"camDeviceId":"id2","camDeviceName":"Desk \"Cam\"","camClsid":"","camWidth":1280,)"
+        R"("camHeight":720,"camFps":30,"camPath":"w-2.mp4"}]})";
+    auto m = parseWebcamConfigs(list);
+    expect(m.size() == 2, "list: two cameras");
+    expect(m.size() == 2 && m[1].deviceName == "Desk \"Cam\"" && m[1].outputPath == "w-2.mp4" &&
+               m[1].width == 1280 && m[1].height == 720,
+           "list: second camera fields, escaped quote");
+    expect(m.size() == 2 && m[0].fps == 30, "list: entry fps not the top-level fps");
+
+    expect(parseWebcamConfigs(R"({"webcamEnabled":true,"webcamPath":"w.mp4","webcams":[]})").size() == 1,
+           "empty list falls back to legacy");
+
+    std::string five = R"({"webcams":[)";
+    for (int i = 0; i < 5; ++i) {
+        five += (i ? "," : "");
+        five += R"({"camDeviceName":"C","camPath":"p)" + std::to_string(i) + R"(.mp4"})";
+    }
+    five += "]}";
+    expect(parseWebcamConfigs(five).size() == 4, "capped at four");
+
+    expect(parseWebcamConfigs(R"({"webcams":[{"camDeviceName":"No path"}]})").empty(),
+           "entry without camPath is skipped");
+
+    if (failures == 0) {
+        std::printf("webcam_config_test: all assertions passed\n");
+        return 0;
+    }
+    std::printf("webcam_config_test: %d assertion(s) failed\n", failures);
+    return 1;
+}
diff --git a/scripts/build-windows-wgc-helper.mjs b/scripts/build-windows-wgc-helper.mjs
index ab4b26c00..143fa689c 100644
--- a/scripts/build-windows-wgc-helper.mjs
+++ b/scripts/build-windows-wgc-helper.mjs
@@ -116,6 +116,14 @@ if (!fs.existsSync(webcamFormatTestPath)) {
 await run(webcamFormatTestPath, [], { cwd: BUILD_DIR });
 console.log(`Passed ${webcamFormatTestPath}`);
 
+const webcamConfigTestPath = path.join(BUILD_DIR, "webcam_config_test.exe");
+if (!fs.existsSync(webcamConfigTestPath)) {
+	throw new Error(`WGC helper build completed but ${webcamConfigTestPath} was not found.`);
+}
+// Guards how the helper reads the list of cameras (and the legacy single-camera fields).
+await run(webcamConfigTestPath, [], { cwd: BUILD_DIR });
+console.log(`Passed ${webcamConfigTestPath}`);
+
 const frameVisibilityTestPath = path.join(BUILD_DIR, "frame_visibility_test.exe");
 if (!fs.existsSync(frameVisibilityTestPath)) {
 	throw new Error(`WGC helper build completed but ${frameVisibilityTestPath} was not found.`);

From d09a1ac6c41e16f7956ff8c9db713ca4073b93d8 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 11:04:28 +0200
Subject: [PATCH 02/22] feat(wgc): record every camera in the config on the
 shared clock

Each camera of the webcams list (or the legacy single-camera fields) gets its own capture and encoder on the recording's T0. A camera that cannot be opened is dropped with an indexed webcam-unavailable warning; one whose samples fail mid-take is disabled on its own. recording-stopped keeps webcamPath and adds webcamPaths.

MFEncoder now only balances an MFStartup it made: a dropped camera's never-initialized encoder ran an unmatched MFShutdown from its destructor and stopped every other encoder in the process.
---
 electron/native/README.md                     |  17 +
 electron/native/wgc-capture/src/main.cpp      | 410 ++++++++++++------
 .../native/wgc-capture/src/mf_encoder.cpp     |   6 +-
 electron/native/wgc-capture/src/mf_encoder.h  |   6 +
 scripts/test-windows-wgc-helper.mjs           |  67 +++
 5 files changed, 363 insertions(+), 143 deletions(-)

diff --git a/electron/native/README.md b/electron/native/README.md
index 5f68fb254..a66efbef8 100644
--- a/electron/native/README.md
+++ b/electron/native/README.md
@@ -85,6 +85,17 @@ Current V2 JSON shape:
 
 The current helper implementation supports display/window video capture, system audio loopback, selected-microphone capture, Media Foundation webcam capture, and a DirectShow webcam fallback for virtual cameras that are not exposed through Media Foundation. Webcam frames are currently composed into the primary MP4 as a bottom-right picture-in-picture overlay. Browser `deviceId` values do not always map to Media Foundation symbolic links or WASAPI endpoint IDs, so the renderer passes both browser IDs and user-visible device names. For microphones, the helper tries the requested WASAPI endpoint ID first, then resolves an active capture endpoint by `microphoneDeviceName`, then falls back to the default endpoint. For webcams, Electron resolves a matching DirectShow filter CLSID for the selected label; the helper uses Media Foundation first, then that exact DirectShow filter when the requested camera is absent from Media Foundation.
 
+Several cameras: a `webcams` list records up to four cameras, each into its own MP4, all on the same T0 as the screen and audio. Each entry takes `camDeviceId`, `camDeviceName`, `camClsid` (the DirectShow filter CLSID), `camWidth`, `camHeight`, `camFps` and `camPath`; an entry without `camPath` is skipped. When the list is present and non-empty it replaces the legacy `webcam*` fields; without it those fields still describe one camera, which writes to `webcamPath` when one is given and is drawn into the screen as the inline picture-in-picture otherwise.
+
+```json
+"webcams": [
+  { "camDeviceId": "…", "camDeviceName": "Camera A", "camClsid": "{…}", "camWidth": 1920, "camHeight": 1080, "camFps": 30, "camPath": "C:\\path\\recording-123-webcam.mp4" },
+  { "camDeviceId": "…", "camDeviceName": "Camera B", "camClsid": "", "camWidth": 1280, "camHeight": 720, "camFps": 30, "camPath": "C:\\path\\recording-123-webcam-2.mp4" }
+]
+```
+
+Every per-camera event carries the camera's `index` in that list: `webcam-format` (`{"event":"webcam-format","schemaVersion":2,"index":0,"width":…,"height":…,"fps":…,"deviceName":"…"}`) for each camera that opened, and `{"event":"warning","code":"webcam-unavailable","index":1,"deviceName":"…","message":"…"}` for each that did not (`code` comes before `index` so older substring readers still match). A camera that cannot be opened is dropped and the rest of the take goes on; a camera whose encoder rejects a sample mid-take is disabled on its own, without stopping the screen or the other cameras. `recording-stopped` keeps `webcamPath` (camera 0, when it recorded) and adds `webcamPaths`, the files of every camera still recording at stop, in index order. Both are printed before the camera files are finalized (see the stop sequence), so a camera whose finalize fails is reported on stderr and by a non-zero exit, not removed from the list. Each camera finalizes in its own `[stop-timing]` step, `webcam-encoder-finalize-<index>`.
+
 Container: recordings are written as fragmented MP4 (`MFCreateFMPEG4MediaSink` + `MFCreateSinkWriterFromMediaSink`, `MF_MPEG4SINK_MIN_FRAGMENT_DURATION` = 1s) rather than plain MP4. A plain MP4 has no index until `IMFSinkWriter::Finalize()` writes `moov` at the very end, so when the shutdown watchdog force-exits a wedged helper the file on disk holds every frame and no way to read them — that is why issues #252 / #292 / #327 cost the whole recording rather than the frozen tail of it. A fragmented MP4 writes its index up front and its samples in self-describing `moof`+`mdat` pairs, so the same kill leaves a file that plays up to the last complete fragment. This does not fix the freeze; it removes the data loss the freeze causes. Because the fragmented sink needs both output media types at construction, the sink writer is built from a media sink instead of from a URL, and the helper reads the video/audio stream positions back off the sink rather than assuming them. If any of that is unavailable on a machine, the helper retries with the plain container and says so — `container` in the `encoder-selection` event is `fragmented-mp4` or `mp4`, and it reports what was used, not what was asked for.
 
 Encoder selection: by default the helper keeps the existing sink-writer path first. If that path fails while setting up H.264, it retries with the Microsoft software H.264 encoder (`mfh264enc.dll`). The key of this retry is registering that encoder locally in the helper process via `MFTRegisterLocalByCLSID`, which makes a software H.264 encoder available even when the machine's hardware encoders are missing or broken; hardware transforms are disabled for the retry only as a secondary guard so the sink writer prefers the locally registered software encoder, not as the fallback mechanism itself. Set `preferSoftwareEncoder: true` in the helper JSON, or set `OPENSCREEN_WGC_PREFER_SOFTWARE_ENCODER=true` before launching Electron, to force the software path from the first attempt.
@@ -126,6 +137,12 @@ npm run test:wgc-webcam:win
 Remove-Item Env:OPENSCREEN_WGC_TEST_WEBCAM_DEVICE_NAME
 ```
 
+To check that a camera which cannot be opened costs only itself, record the real camera next to a nonexistent second one listed through `webcams`:
+
+```powershell
+npm run test:wgc-helper:win -- --webcam --missing-second-webcam
+```
+
 To validate a specific native microphone manually:
 
 ```powershell
diff --git a/electron/native/wgc-capture/src/main.cpp b/electron/native/wgc-capture/src/main.cpp
index 5ba80cd49..a0785dab5 100644
--- a/electron/native/wgc-capture/src/main.cpp
+++ b/electron/native/wgc-capture/src/main.cpp
@@ -10,6 +10,7 @@
 #include "frame_visibility.h"
 #include "json_fields.h"
 #include "webcam_capture.h"
+#include "webcam_config.h"
 #include "wgc_session.h"
 
 #include <winrt/Windows.Foundation.h>
@@ -27,6 +28,7 @@
 #include <ratio>
 #include <string>
 #include <thread>
+#include <vector>
 
 namespace {
 
@@ -38,7 +40,6 @@ struct CaptureConfig {
     std::string sourceId;
     std::string windowHandle;
     std::string outputPath;
-    std::string webcamOutputPath;
     int fps = 60;
     int width = 0;
     int height = 0;
@@ -139,6 +140,49 @@ struct CaptureControl {
     }
 };
 
+// One camera of the take: its capture, its encoder and the writer-loop state that used
+// to be single variables. All cameras share the recording's T0.
+struct WebcamStream {
+    WebcamConfig config;
+    // The camera's position in the config list, kept when an earlier camera is
+    // dropped, so every event names the camera the caller asked for.
+    size_t index = 0;
+    WebcamCapture capture;
+    MFEncoder encoder;
+    bool active = false;
+    // False only for the legacy inline picture-in-picture camera, which has no
+    // file of its own and is drawn into the screen frame instead.
+    bool writeSeparate = false;
+    std::vector<BYTE> latestFrame;
+    int latestWidth = 0;
+    int latestHeight = 0;
+    uint64_t latestSequence = 0;
+    bool hasVisibleFrame = false;
+    int64_t lastTimestampHns = -1;
+    int64_t nextWriteDueHns = 0;
+    int64_t nominalIntervalHns = 0;
+    // Captured in the writer's pull block, submitted after it (issue #115).
+    Microsoft::WRL::ComPtr<IMFSample> pendingSample;
+    // Owned here because the shutdown watchdog reads the current step's name
+    // through a raw pointer from another thread.
+    std::string finalizeStepName;
+
+    // Takes the camera's newest frame if it carries a picture. Returns whether it did.
+    bool pullVisibleFrame() {
+        WebcamFrameSnapshot candidate;
+        if (!capture.copyLatestFrame(candidate, latestSequence) ||
+            !hasVisibleWebcamContent(candidate.data, capture.deliversNv12())) {
+            return false;
+        }
+        latestFrame = std::move(candidate.data);
+        latestWidth = candidate.width;
+        latestHeight = candidate.height;
+        latestSequence = candidate.sequence;
+        hasVisibleFrame = true;
+        return true;
+    }
+};
+
 int readEnvInt(const char* name, int fallback) {
     char raw[32]{};
     const DWORD length = GetEnvironmentVariableA(name, raw, static_cast<DWORD>(sizeof(raw)));
@@ -469,7 +513,6 @@ bool parseConfig(const std::string& json, CaptureConfig& config) {
     config.webcamDeviceId = findString(json, "webcamDeviceId");
     config.webcamDeviceName = findString(json, "webcamDeviceName");
     config.webcamDirectShowClsid = findString(json, "webcamDirectShowClsid");
-    config.webcamOutputPath = findString(json, "webcamPath");
     config.webcamWidth = findInt(json, "webcamWidth", 0);
     config.webcamHeight = findInt(json, "webcamHeight", 0);
     config.webcamFps = findInt(json, "webcamFps", 0);
@@ -544,8 +587,9 @@ int wmain(int argc, wchar_t* argv[]) {
 
     winrt::init_apartment(winrt::apartment_type::multi_threaded);
 
+    const std::string configJson = wideToUtf8(argv[1]);
     CaptureConfig config;
-    if (!parseConfig(wideToUtf8(argv[1]), config)) {
+    if (!parseConfig(configJson, config)) {
         std::cerr << "ERROR: Failed to parse config JSON" << std::endl;
         return 1;
     }
@@ -645,42 +689,67 @@ int wmain(int argc, wchar_t* argv[]) {
     const int pixels = width * height;
     const int bitrate = pixels >= 3840 * 2160 ? 45'000'000 : pixels >= 2560 * 1440 ? 28'000'000 : 18'000'000;
 
-    WebcamCapture webcamCapture;
-    bool webcamActive = false;
-    // Decided before initialize(), not after: it selects the capture pixel
-    // format, and only a camera going to its own file can use NV12 -- an inline
-    // picture-in-picture composite needs the frame as BGRA.
-    bool writeSeparateWebcam = config.webcamEnabled && !config.webcamOutputPath.empty();
-    if (config.webcamEnabled) {
-        if (!webcamCapture.initialize(
-                utf8ToWide(config.webcamDeviceId),
-                utf8ToWide(config.webcamDeviceName),
-                utf8ToWide(config.webcamDirectShowClsid),
-                config.webcamWidth,
-                config.webcamHeight,
-                config.webcamFps > 0 ? config.webcamFps : config.fps,
-                writeSeparateWebcam)) {
+    // Every camera of the take, in config order. The `webcams` list (or the
+    // legacy fields with a webcamPath) gives cameras that each write their own
+    // file. The legacy fields without a webcamPath are the one camera drawn
+    // into the screen frame as an inline picture-in-picture.
+    std::vector<WebcamConfig> webcamConfigs = parseWebcamConfigs(configJson);
+    if (webcamConfigs.empty() && config.webcamEnabled) {
+        WebcamConfig inlineCamera;
+        inlineCamera.deviceId = config.webcamDeviceId;
+        inlineCamera.deviceName = config.webcamDeviceName;
+        inlineCamera.directShowClsid = config.webcamDirectShowClsid;
+        inlineCamera.width = config.webcamWidth;
+        inlineCamera.height = config.webcamHeight;
+        inlineCamera.fps = config.webcamFps;
+        webcamConfigs.push_back(std::move(inlineCamera));
+    }
+
+    std::vector<std::unique_ptr<WebcamStream>> webcams;  // unique_ptr: WebcamCapture/MFEncoder are not movable
+    for (size_t index = 0; index < webcamConfigs.size(); ++index) {
+        auto stream = std::make_unique<WebcamStream>();
+        stream->config = webcamConfigs[index];
+        stream->index = index;
+        stream->finalizeStepName = "webcam-encoder-finalize-" + std::to_string(index);
+        // Decided before initialize(), not after: it selects the capture pixel
+        // format, and only a camera going to its own file can use NV12 -- an inline
+        // picture-in-picture composite needs the frame as BGRA.
+        stream->writeSeparate = !stream->config.outputPath.empty();
+        if (!stream->capture.initialize(
+                utf8ToWide(stream->config.deviceId),
+                utf8ToWide(stream->config.deviceName),
+                utf8ToWide(stream->config.directShowClsid),
+                stream->config.width,
+                stream->config.height,
+                stream->config.fps > 0 ? stream->config.fps : config.fps,
+                stream->writeSeparate)) {
             // Non-fatal: a screen+audio recording the user can still use is far
             // better than losing the whole recording because one camera device
             // didn't match. Report it so the renderer can inform the user (and,
             // historically, fall back to a browser-recorded webcam sidecar), but
-            // let capture continue without a native webcam track.
-            std::cerr << "WARNING: Failed to initialize native webcam capture; continuing without webcam"
-                      << std::endl;
-            std::cout << "{\"event\":\"warning\",\"code\":\"webcam-unavailable\",\"message\":"
-                         "\"Failed to initialize native webcam capture\"}"
-                      << std::endl;
-            config.webcamEnabled = false;
-            writeSeparateWebcam = false;
-        } else {
-            std::cout << "{\"event\":\"webcam-format\",\"schemaVersion\":2,\"width\":" << webcamCapture.width()
-                      << ",\"height\":" << webcamCapture.height()
-                      << ",\"fps\":" << webcamCapture.fps()
-                      << ",\"deviceName\":\"" << jsonEscape(wideToUtf8(webcamCapture.selectedDeviceName()))
-                      << "\"}" << std::endl;
-            // writeSeparateWebcam was decided above, before the pixel format.
+            // let capture continue without this camera's track. `code` stays
+            // ahead of `index`: older readers match on the `"code":…` substring.
+            std::cerr << "WARNING: Failed to initialize native webcam capture for camera " << index
+                      << "; continuing without it" << std::endl;
+            std::cout << "{\"event\":\"warning\",\"code\":\"webcam-unavailable\",\"index\":" << index
+                      << ",\"deviceName\":\"" << jsonEscape(stream->config.deviceName)
+                      << "\",\"message\":\"Failed to initialize native webcam capture\"}" << std::endl;
+            continue;
         }
+        std::cout << "{\"event\":\"webcam-format\",\"schemaVersion\":2,\"index\":" << index
+                  << ",\"width\":" << stream->capture.width()
+                  << ",\"height\":" << stream->capture.height()
+                  << ",\"fps\":" << stream->capture.fps()
+                  << ",\"deviceName\":\"" << jsonEscape(wideToUtf8(stream->capture.selectedDeviceName()))
+                  << "\"}" << std::endl;
+        stream->nominalIntervalHns =
+            static_cast<int64_t>(10'000'000ULL / std::max(1, stream->capture.fps()));
+        webcams.push_back(std::move(stream));
     }
+    // Only the legacy single camera without a file of its own is composited
+    // into the screen frame; every listed camera writes separately.
+    WebcamStream* const inlineWebcam =
+        webcams.size() == 1 && !webcams[0]->writeSeparate ? webcams[0].get() : nullptr;
 
     WasapiLoopbackCapture loopbackCapture;
     WasapiLoopbackCapture microphoneCapture;
@@ -805,13 +874,13 @@ int wmain(int argc, wchar_t* argv[]) {
     //
     // The other two conditions are unchanged and still required: software
     // encoding and inline webcam PiP both need the frame in system memory,
-    // which the DXGI path does not produce. config.webcamEnabled, not
-    // webcamActive -- the latter is only set once webcam capture has started,
-    // well after this.
+    // which the DXGI path does not produce. Decided from the initialized
+    // cameras, not from `active` -- that is only set once webcam capture has
+    // started, well after this.
     encoderOptions.useDxgiInput =
         readEnvInt("OPENSCREEN_WGC_ENABLE_DXGI_INPUT", 0) == 1 &&
         !config.preferSoftwareEncoder &&
-        (!config.webcamEnabled || writeSeparateWebcam);
+        inlineWebcam == nullptr;
 
     MFEncoder encoder;
     if (!encoder.initialize(
@@ -850,8 +919,10 @@ int wmain(int argc, wchar_t* argv[]) {
               // on stop.
               << ",\"videoEncoderRuntime\":\"" << encoder.videoEncoderRuntime()
               << "\"}" << std::endl;
-    MFEncoder webcamEncoder;
-    if (writeSeparateWebcam) {
+    for (const auto& stream : webcams) {
+        if (!stream->writeSeparate) {
+            continue;
+        }
         MFEncoderOptions webcamEncoderOptions = encoderOptions;
         webcamEncoderOptions.injectDefaultSinkWriterFailureOnce = false;
         webcamEncoderOptions.useDxgiInput = false;
@@ -860,23 +931,25 @@ int wmain(int argc, wchar_t* argv[]) {
         // above 640x480; now that the capture runs at the camera's real
         // resolution, 8 Mbit/s starves a 1440p or 2160p frame badly enough to
         // undo the extra pixels. The tiers mirror the screen ladder above.
-        const int webcamPixels = std::max(1, webcamCapture.width()) * std::max(1, webcamCapture.height());
+        const int webcamPixels =
+            std::max(1, stream->capture.width()) * std::max(1, stream->capture.height());
         const int webcamBitrate = webcamPixels >= 3840 * 2160   ? 40'000'000
                                   : webcamPixels >= 2560 * 1440 ? 24'000'000
                                   : webcamPixels >= 1920 * 1080 ? 16'000'000
                                   : webcamPixels >= 1280 * 720  ? 8'000'000
                                                                 : 4'000'000;
-        if (!webcamEncoder.initialize(
-                utf8ToWide(config.webcamOutputPath),
-                webcamCapture.width(),
-                webcamCapture.height(),
-                webcamCapture.fps(),
+        if (!stream->encoder.initialize(
+                utf8ToWide(stream->config.outputPath),
+                stream->capture.width(),
+                stream->capture.height(),
+                stream->capture.fps(),
                 webcamBitrate,
                 session.device(),
                 session.context(),
                 nullptr,
                 webcamEncoderOptions)) {
-            std::cerr << "ERROR: Failed to initialize native webcam encoder" << std::endl;
+            std::cerr << "ERROR: Failed to initialize native webcam encoder for camera "
+                      << stream->index << std::endl;
             return 1;
         }
     }
@@ -903,11 +976,6 @@ int wmain(int argc, wchar_t* argv[]) {
     // them is the next bug report, and neither is worth a log line each.
     std::atomic<uint64_t> contendedFrames = 0;
     Microsoft::WRL::ComPtr<ID3D11Texture2D> latestFrameTexture;
-    std::vector<BYTE> latestWebcamFrame;
-    int latestWebcamWidth = 0;
-    int latestWebcamHeight = 0;
-    uint64_t latestWebcamSequence = 0;
-    bool hasVisibleWebcamFrame = false;
 
     // Legacy-path-only state. frameMutex guards latestFrameTexture/
     // legacyLatestFrameTimestampHns between WGC's callback thread (writer)
@@ -962,7 +1030,6 @@ int wmain(int argc, wchar_t* argv[]) {
             std::chrono::duration<double>(1.0 / config.fps));
         uint64_t frameIndex = 0;
         int64_t lastEncodedVideoTimestampHns = -1;
-        int64_t lastWebcamTimestampHns = -1;
         // Media Foundation's H.264 encoder MFT does not honor irregular input
         // sample times for a VFR source: it numbers output samples
         // sequentially at its configured nominal frame rate regardless of the
@@ -973,18 +1040,17 @@ int wmain(int argc, wchar_t* argv[]) {
         // webcam encoder on a real-time-paced cadence (duplicating the
         // latest available camera frame when the camera hasn't produced a
         // newer one yet), so "sample N is at N/fps" is actually correct.
-        int64_t nextWebcamWriteDueHns = 0;
-        const int64_t nominalWebcamIntervalHns =
-            static_cast<int64_t>(10'000'000ULL / std::max(1, webcamCapture.fps()));
+        // The cadence state is per camera: see WebcamStream.
         auto nextFrameDue = std::chrono::steady_clock::now();
         int64_t firstFrameTimestampHns = -1;
         int64_t latestFrameTimestampHns = 0;
 
         while (!control.stopRequested && !encodeFailed) {
             Microsoft::WRL::ComPtr<IMFSample> videoSample;
-            Microsoft::WRL::ComPtr<IMFSample> webcamSample;
             bool hasVideoSample = false;
-            bool hasWebcamSample = false;
+            for (const auto& stream : webcams) {
+                stream->pendingSample.Reset();
+            }
             // Whether the picture this tick encodes differs from the last one:
             // a new WGC frame, or a new camera frame drawn into it. The legacy
             // callback path cannot tell, so it always reads back.
@@ -1061,22 +1127,20 @@ int wmain(int argc, wchar_t* argv[]) {
                         continue;
                     }
                 }
-                if (webcamActive) {
-                    WebcamFrameSnapshot candidateWebcamFrame;
-                    if (webcamCapture.copyLatestFrame(candidateWebcamFrame, latestWebcamSequence) &&
-                        hasVisibleWebcamContent(candidateWebcamFrame.data, webcamCapture.deliversNv12())) {
-                        latestWebcamFrame = std::move(candidateWebcamFrame.data);
-                        latestWebcamWidth = candidateWebcamFrame.width;
-                        latestWebcamHeight = candidateWebcamFrame.height;
-                        latestWebcamSequence = candidateWebcamFrame.sequence;
-                        hasVisibleWebcamFrame = true;
-                        pictureChanged = pictureChanged || !writeSeparateWebcam;
+                // Screen first, then every camera, as before there was more than one.
+                for (const auto& stream : webcams) {
+                    if (stream->active && stream->pullVisibleFrame()) {
+                        pictureChanged = pictureChanged || !stream->writeSeparate;
                     }
                 }
-                const BgraFrameView webcamFrame{
-                    hasVisibleWebcamFrame && !latestWebcamFrame.empty() ? latestWebcamFrame.data() : nullptr,
-                    latestWebcamWidth,
-                    latestWebcamHeight,
+                // The frame composited into the screen picture, for the legacy
+                // inline camera only.
+                const BgraFrameView inlineWebcamFrame{
+                    inlineWebcam && inlineWebcam->hasVisibleFrame && !inlineWebcam->latestFrame.empty()
+                        ? inlineWebcam->latestFrame.data()
+                        : nullptr,
+                    inlineWebcam ? inlineWebcam->latestWidth : 0,
+                    inlineWebcam ? inlineWebcam->latestHeight : 0,
                 };
                 const int64_t syntheticTimestampHns =
                     static_cast<int64_t>((frameIndex * 10'000'000ULL) / config.fps);
@@ -1094,16 +1158,24 @@ int wmain(int argc, wchar_t* argv[]) {
                     frameTimestampHns =
                         lastEncodedVideoTimestampHns + static_cast<int64_t>(10'000'000ULL / config.fps);
                 }
-                if (writeSeparateWebcam && webcamFrame.data) {
-                    // Anchor to the same recording-start origin as screen video/audio,
-                    // using real elapsed host-clock time (not a synthetic frame-index
-                    // clock) so a long recording can't accumulate clock-origin drift.
-                    const auto elapsedSinceStart = std::chrono::steady_clock::now() - control.recordingStartedAt;
-                    const int64_t elapsedHns = std::chrono::duration_cast<
-                        std::chrono::duration<int64_t, std::ratio<1, 10'000'000>>>(elapsedSinceStart)
-                                                    .count();
-                    const int64_t targetElapsedHns =
-                        std::max<int64_t>(0, elapsedHns - control.pausedDurationHns());
+                // Anchor to the same recording-start origin as screen video/audio,
+                // using real elapsed host-clock time (not a synthetic frame-index
+                // clock) so a long recording can't accumulate clock-origin drift.
+                // Read once per tick: every camera of this tick shares it.
+                int64_t targetElapsedHns = -1;
+                for (const auto& stream : webcams) {
+                    if (!stream->active || !stream->writeSeparate || !stream->hasVisibleFrame ||
+                        stream->latestFrame.empty()) {
+                        continue;
+                    }
+                    if (targetElapsedHns < 0) {
+                        const auto elapsedSinceStart =
+                            std::chrono::steady_clock::now() - control.recordingStartedAt;
+                        const int64_t elapsedHns = std::chrono::duration_cast<
+                            std::chrono::duration<int64_t, std::ratio<1, 10'000'000>>>(elapsedSinceStart)
+                                                        .count();
+                        targetElapsedHns = std::max<int64_t>(0, elapsedHns - control.pausedDurationHns());
+                    }
                     // The H.264 encoder MFT does not honor irregular per-sample
                     // timestamps for a VFR source -- it numbers output samples
                     // sequentially at its configured nominal rate regardless of the
@@ -1112,35 +1184,40 @@ int wmain(int argc, wchar_t* argv[]) {
                     // to feed the encoder *at* that nominal cadence, duplicating
                     // the latest available camera frame when the camera hasn't
                     // produced a newer one yet (VFR capture -> CFR encode resampling).
-                    if (targetElapsedHns >= nextWebcamWriteDueHns) {
-                        int64_t webcamTimestampHns = targetElapsedHns;
-                        if (lastWebcamTimestampHns >= 0 && webcamTimestampHns <= lastWebcamTimestampHns) {
-                            webcamTimestampHns = lastWebcamTimestampHns + nominalWebcamIntervalHns;
-                        }
-                        // Capture the sample here, but submit it to the sink
-                        // writer OUTSIDE this block below (issue #115) so a
-                        // slow WriteSample can't hold up the next frame pull.
-                        hasWebcamSample =
-                            webcamCapture.deliversNv12()
-                                ? webcamEncoder.captureNv12Sample(
-                                      Nv12FrameView{
-                                          webcamFrame.data, webcamFrame.width, webcamFrame.height},
-                                      webcamTimestampHns,
-                                      webcamSample)
-                                : webcamEncoder.captureBgraSample(
-                                      webcamFrame, webcamTimestampHns, webcamSample);
-                        if (!hasWebcamSample) {
-                            encodeFailed = true;
-                            control.requestStop();
-                            break;
-                        }
-                        lastWebcamTimestampHns = webcamTimestampHns;
-                        nextWebcamWriteDueHns += nominalWebcamIntervalHns;
-                        if (nextWebcamWriteDueHns <= targetElapsedHns) {
-                            // Fell behind (e.g. coming out of a pause, or a stall) --
-                            // resync to now instead of trying to catch up frame-by-frame.
-                            nextWebcamWriteDueHns = targetElapsedHns + nominalWebcamIntervalHns;
-                        }
+                    if (targetElapsedHns < stream->nextWriteDueHns) {
+                        continue;
+                    }
+                    int64_t webcamTimestampHns = targetElapsedHns;
+                    if (stream->lastTimestampHns >= 0 && webcamTimestampHns <= stream->lastTimestampHns) {
+                        webcamTimestampHns = stream->lastTimestampHns + stream->nominalIntervalHns;
+                    }
+                    const BgraFrameView webcamFrame{
+                        stream->latestFrame.data(), stream->latestWidth, stream->latestHeight};
+                    // Capture the sample here, but submit it to the sink
+                    // writer OUTSIDE this block below (issue #115) so a
+                    // slow WriteSample can't hold up the next frame pull.
+                    const bool captured =
+                        stream->capture.deliversNv12()
+                            ? stream->encoder.captureNv12Sample(
+                                  Nv12FrameView{webcamFrame.data, webcamFrame.width, webcamFrame.height},
+                                  webcamTimestampHns,
+                                  stream->pendingSample)
+                            : stream->encoder.captureBgraSample(
+                                  webcamFrame, webcamTimestampHns, stream->pendingSample);
+                    if (!captured) {
+                        // One camera failing costs that camera, not the take.
+                        std::cerr << "ERROR: Failed to capture a sample for camera " << stream->index
+                                  << "; disabling it" << std::endl;
+                        stream->pendingSample.Reset();
+                        stream->active = false;
+                        continue;
+                    }
+                    stream->lastTimestampHns = webcamTimestampHns;
+                    stream->nextWriteDueHns += stream->nominalIntervalHns;
+                    if (stream->nextWriteDueHns <= targetElapsedHns) {
+                        // Fell behind (e.g. coming out of a pause, or a stall) --
+                        // resync to now instead of trying to catch up frame-by-frame.
+                        stream->nextWriteDueHns = targetElapsedHns + stream->nominalIntervalHns;
                     }
                 }
                 if (testStallReadbackMs > 0) {
@@ -1178,7 +1255,7 @@ int wmain(int argc, wchar_t* argv[]) {
                         captured = encoder.captureVideoSample(
                             latestFrameTexture.Get(),
                             frameTimestampHns,
-                            !writeSeparateWebcam && webcamFrame.data ? &webcamFrame : nullptr,
+                            inlineWebcamFrame.data ? &inlineWebcamFrame : nullptr,
                             videoSample);
                     }
                     if (!captured) {
@@ -1218,10 +1295,15 @@ int wmain(int argc, wchar_t* argv[]) {
             // Stop detection has nothing to do with this ordering -- that is
             // CaptureControl::stopMutex/stopCv, checked by the loop condition
             // above, unrelated to sample submission (issue #252).
-            if (hasWebcamSample && !webcamEncoder.submitVideoSample(webcamSample.Get())) {
-                encodeFailed = true;
-                control.requestStop();
-                break;
+            for (const auto& stream : webcams) {
+                if (stream->pendingSample && !stream->encoder.submitVideoSample(stream->pendingSample.Get())) {
+                    // Disables this camera only; the screen and the other
+                    // cameras keep recording.
+                    std::cerr << "ERROR: Failed to submit a sample for camera " << stream->index
+                              << "; disabling it" << std::endl;
+                    stream->active = false;
+                }
+                stream->pendingSample.Reset();
             }
             if (hasVideoSample && !encoder.submitVideoSample(videoSample.Get())) {
                 encodeFailed = true;
@@ -1347,8 +1429,14 @@ int wmain(int argc, wchar_t* argv[]) {
         stopRenderKeepAliveIfActive();
         return 1;
     }
-    if (config.webcamEnabled) {
-        if (!webcamCapture.start()) {
+    const auto stopWebcamCaptures = [&]() {
+        for (const auto& stream : webcams) {
+            stream->capture.stop();
+        }
+    };
+    for (const auto& stream : webcams) {
+        if (!stream->capture.start()) {
+            stopWebcamCaptures();
             microphoneCapture.stop();
             loopbackCapture.stop();
             stopDeviceWatchIfActive();
@@ -1356,32 +1444,43 @@ int wmain(int argc, wchar_t* argv[]) {
             if (audioMixer) {
                 audioMixer->stop();
             }
-            std::cerr << "ERROR: Failed to start native webcam capture" << std::endl;
+            std::cerr << "ERROR: Failed to start native webcam capture for camera " << stream->index
+                      << std::endl;
             return 1;
         }
-        webcamActive = true;
+        stream->active = true;
+    }
+    if (!webcams.empty()) {
+        // One 3 s budget for all cameras together, not 3 s each: they warm up
+        // in parallel, and the screen recording should not start later per camera.
         const auto webcamDeadline = std::chrono::steady_clock::now() + std::chrono::seconds(3);
-        while (std::chrono::steady_clock::now() < webcamDeadline && !hasVisibleWebcamFrame) {
-            WebcamFrameSnapshot candidateWebcamFrame;
-            if (webcamCapture.copyLatestFrame(candidateWebcamFrame, latestWebcamSequence) &&
-                hasVisibleWebcamContent(candidateWebcamFrame.data, webcamCapture.deliversNv12())) {
-                latestWebcamFrame = std::move(candidateWebcamFrame.data);
-                latestWebcamWidth = candidateWebcamFrame.width;
-                latestWebcamHeight = candidateWebcamFrame.height;
-                latestWebcamSequence = candidateWebcamFrame.sequence;
-                hasVisibleWebcamFrame = true;
+        const auto allVisible = [&]() {
+            return std::all_of(webcams.begin(), webcams.end(), [](const auto& stream) {
+                return stream->hasVisibleFrame;
+            });
+        };
+        while (std::chrono::steady_clock::now() < webcamDeadline && !allVisible()) {
+            for (const auto& stream : webcams) {
+                if (!stream->hasVisibleFrame) {
+                    stream->pullVisibleFrame();
+                }
+            }
+            if (allVisible()) {
                 break;
             }
             std::this_thread::sleep_for(std::chrono::milliseconds(20));
         }
-        if (!hasVisibleWebcamFrame) {
-            std::cerr << "WARNING: Native webcam started but no visible frame was available before screen capture"
-                      << std::endl;
+        for (const auto& stream : webcams) {
+            if (!stream->hasVisibleFrame) {
+                std::cerr << "WARNING: Native webcam " << stream->index
+                          << " started but no visible frame was available before screen capture"
+                          << std::endl;
+            }
         }
     }
 
     if (!session.start()) {
-        webcamCapture.stop();
+        stopWebcamCaptures();
         microphoneCapture.stop();
         loopbackCapture.stop();
         stopDeviceWatchIfActive();
@@ -1431,7 +1530,7 @@ int wmain(int argc, wchar_t* argv[]) {
         loopbackCapture.stop();
         stopDeviceWatchIfActive();
         stopRenderKeepAliveIfActive();
-        webcamCapture.stop();
+        stopWebcamCaptures();
         if (audioMixer) {
             audioMixer->stop();
         }
@@ -1588,7 +1687,7 @@ int wmain(int argc, wchar_t* argv[]) {
         logStopStep("render-keepalive");
     }
     beginStopStep("webcam", stepBudgetMs);
-    webcamCapture.stop();
+    stopWebcamCaptures();
     logStopStep("webcam");
     beginStopStep("audio-mixer", stepBudgetMs);
     if (audioMixer) {
@@ -1684,20 +1783,47 @@ int wmain(int argc, wchar_t* argv[]) {
     if (!encodeFailed && screenFinalized) {
         std::cout << "{\"event\":\"recording-stopped\",\"schemaVersion\":2,\"screenPath\":\""
                   << jsonEscape(config.outputPath) << "\"";
-        if (writeSeparateWebcam) {
-            std::cout << ",\"webcamPath\":\"" << jsonEscape(config.webcamOutputPath) << "\"";
+        // `webcamPath` stays for camera 0, as before; `webcamPaths` lists every
+        // camera still recording at stop, in index order. Both are printed
+        // before the camera files are finalized, for the reason above -- so they
+        // name the files that were being written, and a camera whose finalize
+        // fails below is reported on stderr, not removed from this list.
+        std::vector<const WebcamStream*> recordedWebcams;
+        for (const auto& stream : webcams) {
+            if (stream->writeSeparate && stream->active) {
+                recordedWebcams.push_back(stream.get());
+            }
+        }
+        if (!recordedWebcams.empty() && recordedWebcams.front()->index == 0) {
+            std::cout << ",\"webcamPath\":\"" << jsonEscape(recordedWebcams.front()->config.outputPath)
+                      << "\"";
+        }
+        if (!recordedWebcams.empty()) {
+            std::cout << ",\"webcamPaths\":[";
+            for (size_t i = 0; i < recordedWebcams.size(); ++i) {
+                std::cout << (i == 0 ? "\"" : ",\"") << jsonEscape(recordedWebcams[i]->config.outputPath)
+                          << "\"";
+            }
+            std::cout << "]";
         }
         std::cout << "}" << std::endl;
         std::cout << "Recording stopped. Output path: " << config.outputPath << std::endl;
     }
 
+    // Every camera that wrote a file is finalized, including one disabled
+    // mid-take: what it wrote before failing is still worth a playable index.
     bool webcamFinalized = true;
-    if (writeSeparateWebcam) {
-        beginStopStep("webcam-encoder-finalize", shutdownBudgetMs);
-        webcamFinalized = webcamEncoder.finalize();
-        logStopStep("webcam-encoder-finalize");
-        if (!webcamFinalized) {
-            std::cerr << "ERROR: Failed to finalize the webcam recording" << std::endl;
+    for (const auto& stream : webcams) {
+        if (!stream->writeSeparate) {
+            continue;
+        }
+        beginStopStep(stream->finalizeStepName.c_str(), shutdownBudgetMs);
+        const bool finalized = stream->encoder.finalize();
+        logStopStep(stream->finalizeStepName.c_str());
+        if (!finalized) {
+            std::cerr << "ERROR: Failed to finalize the webcam recording for camera " << stream->index
+                      << std::endl;
+            webcamFinalized = false;
         }
     }
 
diff --git a/electron/native/wgc-capture/src/mf_encoder.cpp b/electron/native/wgc-capture/src/mf_encoder.cpp
index 9eac8c4b4..23bc69331 100644
--- a/electron/native/wgc-capture/src/mf_encoder.cpp
+++ b/electron/native/wgc-capture/src/mf_encoder.cpp
@@ -786,6 +786,7 @@ bool MFEncoder::initialize(
     if (!succeeded(MFStartup(MF_VERSION), "MFStartup")) {
         return false;
     }
+    mfStarted_ = true;
 
     if (useDxgiInput_ && !initializeDxgiPipeline()) {
         std::cerr << "WARNING: The GPU DXGI encode path is unavailable on this machine; "
@@ -1984,6 +1985,9 @@ bool MFEncoder::finalize() {
     captureDevice_.Reset();
     context_.Reset();
     device_.Reset();
-    MFShutdown();
+    if (mfStarted_) {
+        MFShutdown();
+        mfStarted_ = false;
+    }
     return ok;
 }
diff --git a/electron/native/wgc-capture/src/mf_encoder.h b/electron/native/wgc-capture/src/mf_encoder.h
index 455624135..4c2034f87 100644
--- a/electron/native/wgc-capture/src/mf_encoder.h
+++ b/electron/native/wgc-capture/src/mf_encoder.h
@@ -269,6 +269,12 @@ class MFEncoder {
     int64_t firstTimestampHns_ = -1;
     int64_t lastTimestampHns_ = -1;
     bool finalized_ = false;
+    // Whether initialize() got as far as a successful MFStartup(). finalize()
+    // may only balance a startup this encoder made: MF's startup count is
+    // process-wide, and an encoder that was never initialized (a dropped
+    // camera's) would otherwise shut Media Foundation down under every other
+    // encoder and camera still running.
+    bool mfStarted_ = false;
     bool useDxgiInput_ = false;
     const char* videoEncoderSelection_ = kVideoEncoderSelectionDefault;
     const char* videoEncoderRuntime_ = kVideoEncoderRuntimeUnknown;
diff --git a/scripts/test-windows-wgc-helper.mjs b/scripts/test-windows-wgc-helper.mjs
index 0ff318bc0..62e1d9fde 100644
--- a/scripts/test-windows-wgc-helper.mjs
+++ b/scripts/test-windows-wgc-helper.mjs
@@ -39,6 +39,15 @@ const WITH_WINDOW_POPUP =
 	process.argv.includes("--window-popup");
 const WITH_WEBCAM =
 	process.env.OPENSCREEN_WGC_TEST_WEBCAM === "true" || process.argv.includes("--webcam");
+/**
+ * Adds a second camera that does not exist to a `--webcam` run, listed through
+ * the `webcams` config next to the real one: the helper must drop only that
+ * camera, say so with its index, and still record the first.
+ */
+const WITH_MISSING_SECOND_WEBCAM =
+	process.env.OPENSCREEN_WGC_TEST_MISSING_SECOND_WEBCAM === "true" ||
+	process.argv.includes("--missing-second-webcam");
+const MISSING_WEBCAM_NAME = "OpenScreen Nonexistent Camera";
 const CAPTURE_CURSOR =
 	process.env.OPENSCREEN_WGC_TEST_CAPTURE_CURSOR === "true" ||
 	process.argv.includes("--capture-cursor");
@@ -107,6 +116,9 @@ const STOP_LATENCY_BUDGET_MS = 15_000;
 if (WITH_SOFTWARE_ENCODER && WITH_SOFTWARE_FALLBACK) {
 	throw new Error("--software-encoder and --software-fallback are mutually exclusive");
 }
+if (WITH_MISSING_SECOND_WEBCAM && !WITH_WEBCAM) {
+	throw new Error("--missing-second-webcam needs --webcam");
+}
 
 function runHelper(
 	config,
@@ -860,6 +872,9 @@ const outputPath = path.join(
 	`openscreen-wgc-helper-${WITH_WEBCAM ? "webcam" : WITH_WINDOW ? "window" : WITH_SYSTEM_AUDIO || WITH_MICROPHONE ? "audio" : "video"}-${process.pid}-${Date.now()}-${randomUUID()}.mp4`,
 );
 const webcamOutputPath = WITH_WEBCAM ? outputPath.replace(/\.mp4$/i, "-webcam.mp4") : null;
+const missingWebcamOutputPath = WITH_MISSING_SECOND_WEBCAM
+	? outputPath.replace(/\.mp4$/i, "-webcam-2.mp4")
+	: null;
 
 const fixtureWindow = WITH_WINDOW ? await startFixtureWindow() : null;
 
@@ -904,6 +919,29 @@ const config = {
 	},
 };
 
+if (WITH_MISSING_SECOND_WEBCAM) {
+	config.webcams = [
+		{
+			camDeviceId: config.webcamDeviceId,
+			camDeviceName: config.webcamDeviceName,
+			camClsid: config.webcamDirectShowClsid,
+			camWidth: config.webcamWidth,
+			camHeight: config.webcamHeight,
+			camFps: config.webcamFps,
+			camPath: webcamOutputPath,
+		},
+		{
+			camDeviceId: "",
+			camDeviceName: MISSING_WEBCAM_NAME,
+			camClsid: "",
+			camWidth: 1280,
+			camHeight: 720,
+			camFps: 30,
+			camPath: missingWebcamOutputPath,
+		},
+	];
+}
+
 if (WITH_WINDOW_POPUP) {
 	const scriptPath = path.join(os.tmpdir(), `openscreen-popup-fixture-${process.pid}.ps1`);
 	fs.writeFileSync(scriptPath, POPUP_FIXTURE_SCRIPT);
@@ -1111,6 +1149,35 @@ if (
 if (WITH_WEBCAM && !webcamStreams.some((stream) => stream.codec_type === "video")) {
 	throw new Error(`WGC helper webcam output has no video stream: ${webcamOutputPath}`);
 }
+if (WITH_MISSING_SECOND_WEBCAM) {
+	const unavailable = result.stdout
+		.split(/\r?\n/)
+		.filter((line) => line.includes('"code":"webcam-unavailable"'))
+		.map((line) => JSON.parse(line.slice(line.indexOf('{"event"'))));
+	if (!unavailable.some((event) => event.index === 1 && event.deviceName === MISSING_WEBCAM_NAME)) {
+		throw new Error(
+			`WGC helper did not report camera 1 (${MISSING_WEBCAM_NAME}) as unavailable: ${result.stdout}`,
+		);
+	}
+	const stoppedLine = result.stdout
+		.split(/\r?\n/)
+		.find((line) => line.includes('"event":"recording-stopped"'));
+	const stopped = stoppedLine
+		? JSON.parse(stoppedLine.slice(stoppedLine.indexOf('{"event"')))
+		: null;
+	if (JSON.stringify(stopped?.webcamPaths) !== JSON.stringify([webcamOutputPath])) {
+		throw new Error(
+			`recording-stopped.webcamPaths should list only the real camera: ${stoppedLine ?? "missing"}`,
+		);
+	}
+	if (fs.existsSync(missingWebcamOutputPath) && fs.statSync(missingWebcamOutputPath).size > 0) {
+		throw new Error(`WGC helper wrote a file for the missing camera: ${missingWebcamOutputPath}`);
+	}
+	console.log("WGC helper missing-second-webcam check passed", {
+		unavailable,
+		webcamPaths: stopped.webcamPaths,
+	});
+}
 if (
 	(CAPTURE_CURSOR && !cursorCapture) ||
 	(cursorCapture &&

From e86b382ee5b362be7851fb2d6d718ab9836e43f1 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 11:38:05 +0200
Subject: [PATCH 03/22] fix(wgc): drop a camera whose encoder cannot start

A camera whose encoder initialize() or capture start() fails is now warned about with the indexed webcam-unavailable event and dropped, instead of ending the take; its encoder is finalized and its empty file removed. The screen encoder's failure stays fatal.

mf_encoder_color_test pins the MFEncoder fix: finalizing a never-initialized encoder must leave a live one able to write and finalize.
---
 electron/native/README.md                     |  2 +-
 electron/native/wgc-capture/src/main.cpp      | 70 +++++++++++-----
 .../wgc-capture/src/mf_encoder_color_test.cpp | 79 +++++++++++++++++++
 3 files changed, 130 insertions(+), 21 deletions(-)

diff --git a/electron/native/README.md b/electron/native/README.md
index a66efbef8..316622866 100644
--- a/electron/native/README.md
+++ b/electron/native/README.md
@@ -94,7 +94,7 @@ Several cameras: a `webcams` list records up to four cameras, each into its own
 ]
 ```
 
-Every per-camera event carries the camera's `index` in that list: `webcam-format` (`{"event":"webcam-format","schemaVersion":2,"index":0,"width":…,"height":…,"fps":…,"deviceName":"…"}`) for each camera that opened, and `{"event":"warning","code":"webcam-unavailable","index":1,"deviceName":"…","message":"…"}` for each that did not (`code` comes before `index` so older substring readers still match). A camera that cannot be opened is dropped and the rest of the take goes on; a camera whose encoder rejects a sample mid-take is disabled on its own, without stopping the screen or the other cameras. `recording-stopped` keeps `webcamPath` (camera 0, when it recorded) and adds `webcamPaths`, the files of every camera still recording at stop, in index order. Both are printed before the camera files are finalized (see the stop sequence), so a camera whose finalize fails is reported on stderr and by a non-zero exit, not removed from the list. Each camera finalizes in its own `[stop-timing]` step, `webcam-encoder-finalize-<index>`.
+Every per-camera event carries the camera's `index` in that list: `webcam-format` (`{"event":"webcam-format","schemaVersion":2,"index":0,"width":…,"height":…,"fps":…,"deviceName":"…"}`) for each camera that opened, and `{"event":"warning","code":"webcam-unavailable","index":1,"deviceName":"…","message":"…"}` for each that did not (`code` comes before `index` so older substring readers still match). A camera that cannot be opened, or whose encoder or capture will not start (the message says which), is dropped and the rest of the take goes on; a camera whose encoder rejects a sample mid-take is disabled on its own, without stopping the screen or the other cameras. `recording-stopped` keeps `webcamPath` (camera 0, when it recorded) and adds `webcamPaths`, the files of every camera still recording at stop, in index order. Both are printed before the camera files are finalized (see the stop sequence), so a camera whose finalize fails is reported on stderr and by a non-zero exit, not removed from the list. Each camera finalizes in its own `[stop-timing]` step, `webcam-encoder-finalize-<index>`.
 
 Container: recordings are written as fragmented MP4 (`MFCreateFMPEG4MediaSink` + `MFCreateSinkWriterFromMediaSink`, `MF_MPEG4SINK_MIN_FRAGMENT_DURATION` = 1s) rather than plain MP4. A plain MP4 has no index until `IMFSinkWriter::Finalize()` writes `moov` at the very end, so when the shutdown watchdog force-exits a wedged helper the file on disk holds every frame and no way to read them — that is why issues #252 / #292 / #327 cost the whole recording rather than the frozen tail of it. A fragmented MP4 writes its index up front and its samples in self-describing `moof`+`mdat` pairs, so the same kill leaves a file that plays up to the last complete fragment. This does not fix the freeze; it removes the data loss the freeze causes. Because the fragmented sink needs both output media types at construction, the sink writer is built from a media sink instead of from a URL, and the helper reads the video/audio stream positions back off the sink rather than assuming them. If any of that is unavailable on a machine, the helper retries with the plain container and says so — `container` in the `encoder-selection` event is `fragmented-mp4` or `mp4`, and it reports what was used, not what was asked for.
 
diff --git a/electron/native/wgc-capture/src/main.cpp b/electron/native/wgc-capture/src/main.cpp
index a0785dab5..20e14382c 100644
--- a/electron/native/wgc-capture/src/main.cpp
+++ b/electron/native/wgc-capture/src/main.cpp
@@ -442,6 +442,13 @@ void reportCaptureAdapters(ID3D11Device* device, HMONITOR targetMonitor) {
 
 
 
+// `code` stays ahead of `index`: older readers match on the `"code":…` substring.
+void printWebcamUnavailable(size_t index, const std::string& deviceName, const char* message) {
+    std::cout << "{\"event\":\"warning\",\"code\":\"webcam-unavailable\",\"index\":" << index
+              << ",\"deviceName\":\"" << jsonEscape(deviceName) << "\",\"message\":\"" << message << "\"}"
+              << std::endl;
+}
+
 std::string parseWindowHandleFromSourceId(const std::string& sourceId) {
     constexpr char prefix[] = "window:";
     if (sourceId.rfind(prefix, 0) != 0) {
@@ -727,13 +734,11 @@ int wmain(int argc, wchar_t* argv[]) {
             // better than losing the whole recording because one camera device
             // didn't match. Report it so the renderer can inform the user (and,
             // historically, fall back to a browser-recorded webcam sidecar), but
-            // let capture continue without this camera's track. `code` stays
-            // ahead of `index`: older readers match on the `"code":…` substring.
+            // let capture continue without this camera's track.
             std::cerr << "WARNING: Failed to initialize native webcam capture for camera " << index
                       << "; continuing without it" << std::endl;
-            std::cout << "{\"event\":\"warning\",\"code\":\"webcam-unavailable\",\"index\":" << index
-                      << ",\"deviceName\":\"" << jsonEscape(stream->config.deviceName)
-                      << "\",\"message\":\"Failed to initialize native webcam capture\"}" << std::endl;
+            printWebcamUnavailable(
+                index, stream->config.deviceName, "Failed to initialize native webcam capture");
             continue;
         }
         std::cout << "{\"event\":\"webcam-format\",\"schemaVersion\":2,\"index\":" << index
@@ -748,8 +753,38 @@ int wmain(int argc, wchar_t* argv[]) {
     }
     // Only the legacy single camera without a file of its own is composited
     // into the screen frame; every listed camera writes separately.
-    WebcamStream* const inlineWebcam =
+    WebcamStream* inlineWebcam =
         webcams.size() == 1 && !webcams[0]->writeSeparate ? webcams[0].get() : nullptr;
+    // A camera that opened but whose encoder or capture then would not start
+    // costs that camera, not the take -- with the screen and up to four cameras,
+    // running out of hardware encoder sessions is the likeliest way to get here.
+    // Only before the video writer runs: the vector is not touched after that.
+    const auto dropWebcam = [&](WebcamStream& stream, const char* message) {
+        std::cerr << "WARNING: " << message << " for camera " << stream.index << "; continuing without it"
+                  << std::endl;
+        printWebcamUnavailable(stream.index, stream.config.deviceName, message);
+        stream.capture.stop();
+        if (stream.writeSeparate) {
+            // Balances whatever initialize() got through, then removes the
+            // file it may have created: nothing was ever written to it.
+            stream.encoder.finalize();
+            DeleteFileW(utf8ToWide(stream.config.outputPath).c_str());
+        }
+        stream.active = false;
+        if (inlineWebcam == &stream) {
+            inlineWebcam = nullptr;
+        }
+    };
+    const auto eraseDroppedWebcams = [&](const std::vector<const WebcamStream*>& dropped) {
+        webcams.erase(
+            std::remove_if(
+                webcams.begin(),
+                webcams.end(),
+                [&](const std::unique_ptr<WebcamStream>& stream) {
+                    return std::find(dropped.begin(), dropped.end(), stream.get()) != dropped.end();
+                }),
+            webcams.end());
+    };
 
     WasapiLoopbackCapture loopbackCapture;
     WasapiLoopbackCapture microphoneCapture;
@@ -919,6 +954,7 @@ int wmain(int argc, wchar_t* argv[]) {
               // on stop.
               << ",\"videoEncoderRuntime\":\"" << encoder.videoEncoderRuntime()
               << "\"}" << std::endl;
+    std::vector<const WebcamStream*> droppedWebcams;
     for (const auto& stream : webcams) {
         if (!stream->writeSeparate) {
             continue;
@@ -948,11 +984,11 @@ int wmain(int argc, wchar_t* argv[]) {
                 session.context(),
                 nullptr,
                 webcamEncoderOptions)) {
-            std::cerr << "ERROR: Failed to initialize native webcam encoder for camera "
-                      << stream->index << std::endl;
-            return 1;
+            dropWebcam(*stream, "Failed to initialize native webcam encoder");
+            droppedWebcams.push_back(stream.get());
         }
     }
+    eraseDroppedWebcams(droppedWebcams);
 
     // By default, no mutex guards frame handoff: writeVideoFrames is the
     // only thread that ever touches WGC or latestFrameTexture. It pulls each
@@ -1434,22 +1470,16 @@ int wmain(int argc, wchar_t* argv[]) {
             stream->capture.stop();
         }
     };
+    droppedWebcams.clear();
     for (const auto& stream : webcams) {
         if (!stream->capture.start()) {
-            stopWebcamCaptures();
-            microphoneCapture.stop();
-            loopbackCapture.stop();
-            stopDeviceWatchIfActive();
-            stopRenderKeepAliveIfActive();
-            if (audioMixer) {
-                audioMixer->stop();
-            }
-            std::cerr << "ERROR: Failed to start native webcam capture for camera " << stream->index
-                      << std::endl;
-            return 1;
+            dropWebcam(*stream, "Failed to start native webcam capture");
+            droppedWebcams.push_back(stream.get());
+            continue;
         }
         stream->active = true;
     }
+    eraseDroppedWebcams(droppedWebcams);
     if (!webcams.empty()) {
         // One 3 s budget for all cameras together, not 3 s each: they warm up
         // in parallel, and the screen recording should not start later per camera.
diff --git a/electron/native/wgc-capture/src/mf_encoder_color_test.cpp b/electron/native/wgc-capture/src/mf_encoder_color_test.cpp
index 1cc20d6b0..ac33a5e1b 100644
--- a/electron/native/wgc-capture/src/mf_encoder_color_test.cpp
+++ b/electron/native/wgc-capture/src/mf_encoder_color_test.cpp
@@ -15,12 +15,14 @@
 #include <wrl/client.h>
 
 #include <algorithm>
+#include <atomic>
 #include <chrono>
 #include <cmath>
 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
 #include <string>
+#include <thread>
 #include <vector>
 
 namespace {
@@ -358,10 +360,87 @@ void checkRepeatedFrames(ID3D11Device* device, ID3D11DeviceContext* context) {
     }
 }
 
+// An encoder that was never initialized -- a camera the helper dropped before
+// its encoder was set up -- must not touch Media Foundation when it is
+// finalized or destroyed. Its finalize() used to call an unmatched MFShutdown(),
+// which in the helper left every other encoder writing nothing (Finalize:
+// MF_E_SINK_NO_SAMPLES_PROCESSED). With an initialized encoder alive, as here,
+// that takes MF's count to zero under a live sink writer, and the live encoder
+// then blocks instead of failing -- so the whole sequence runs on its own thread
+// with a deadline, and a regression fails this test instead of hanging the
+// build. Needs no ffmpeg.
+void checkUninitializedEncoderLeavesOthersRunning() {
+    Microsoft::WRL::ComPtr<ID3D11Device> device;
+    Microsoft::WRL::ComPtr<ID3D11DeviceContext> context;
+    if (FAILED(D3D11CreateDevice(
+            nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, D3D11_CREATE_DEVICE_BGRA_SUPPORT, nullptr, 0,
+            D3D11_SDK_VERSION, &device, nullptr, &context)) &&
+        FAILED(D3D11CreateDevice(
+            nullptr, D3D_DRIVER_TYPE_WARP, nullptr, D3D11_CREATE_DEVICE_BGRA_SUPPORT, nullptr, 0,
+            D3D11_SDK_VERSION, &device, nullptr, &context))) {
+        skip("uninitialized-encoder-leaves-mf-running", "no D3D11 device");
+        return;
+    }
+    char tempDir[MAX_PATH]{};
+    GetTempPathA(MAX_PATH, tempDir);
+    const std::string path = std::string(tempDir) + "openscreen-mf-encoder-uninitialized-peer.mp4";
+    DeleteFileA(path.c_str());
+
+    // 0 running, 1 passed, 2 failed, 3 skipped.
+    std::atomic<int> outcome = 0;
+    std::thread worker([&] {
+        CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+        {
+            MFEncoder live;
+            if (!live.initialize(
+                    widen(path), kWidth, kHeight, 30, 2'000'000, device.Get(), context.Get(), nullptr, {})) {
+                outcome = 3;
+            } else {
+                {
+                    MFEncoder neverInitialized;
+                    neverInitialized.finalize();
+                }  // and destroyed, which finalizes again
+                Microsoft::WRL::ComPtr<IMFSample> probe;
+                std::vector<BYTE> bgra(static_cast<size_t>(kWidth) * kHeight * 4, 0x80);
+                const BgraFrameView frame{bgra.data(), kWidth, kHeight};
+                bool wrote = SUCCEEDED(MFCreateSample(&probe));
+                for (int i = 0; i < kFrames && wrote; i += 1) {
+                    Microsoft::WRL::ComPtr<IMFSample> sample;
+                    wrote = live.captureBgraSample(frame, static_cast<int64_t>(i) * 333'333, sample) &&
+                            live.submitVideoSample(sample.Get());
+                }
+                outcome = wrote && live.finalize() ? 1 : 2;
+            }
+        }
+        CoUninitialize();
+    });
+    const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(30);
+    while (outcome == 0 && std::chrono::steady_clock::now() < deadline) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(20));
+    }
+    if (outcome == 0) {
+        expect("uninitialized-encoder-leaves-mf-running", false, "the live encoder blocked in Media Foundation");
+        std::cout << "ran " << g_ran << " tests\n" << g_failed << " failed" << std::endl;
+        // The blocked thread can be neither joined nor safely abandoned.
+        TerminateProcess(GetCurrentProcess(), 1);
+    }
+    worker.join();
+    DeleteFileA(path.c_str());
+    if (outcome == 3) {
+        skip("uninitialized-encoder-leaves-mf-running", "encoder initialize failed on this host");
+        return;
+    }
+    expect("uninitialized-encoder-leaves-mf-running", outcome == 1, "write or finalize failed");
+}
+
 } // namespace
 
 int main() {
     checkConverterAgainstReference();
+    if (SUCCEEDED(CoInitializeEx(nullptr, COINIT_MULTITHREADED))) {
+        checkUninitializedEncoderLeavesOthersRunning();
+        CoUninitialize();
+    }
     if (!toolsAvailable()) {
         skip("mf-encoder-color", "ffprobe/ffmpeg not on PATH");
         return g_failed == 0 ? 0 : 1;

From bce2d6d82550fca4bf52962be7b195f2a69b6b8e Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 11:44:41 +0200
Subject: [PATCH 04/22] feat(recording): read per-camera helper events

---
 .../nativeWindowsCaptureStop.test.ts          | 63 ++++++++++++++++
 .../recording/nativeWindowsCaptureStop.ts     | 72 +++++++++++++++++++
 2 files changed, 135 insertions(+)

diff --git a/electron/recording/nativeWindowsCaptureStop.test.ts b/electron/recording/nativeWindowsCaptureStop.test.ts
index e277eceec..6391569c2 100644
--- a/electron/recording/nativeWindowsCaptureStop.test.ts
+++ b/electron/recording/nativeWindowsCaptureStop.test.ts
@@ -9,7 +9,10 @@ import {
 	readMicrophoneUnavailable,
 	readSecondaryWindowsApplied,
 	readStoppedPath,
+	readStoppedWebcamPaths,
+	readUnavailableWebcamIndices,
 	readWebcamFormat,
+	readWebcamFormatAt,
 	readWebcamUnavailable,
 	terminateNativeWindowsCapture,
 	waitForNativeWindowsCaptureStop,
@@ -539,3 +542,63 @@ describe("terminateNativeWindowsCapture", () => {
 		expect(helper.killCalls).toBe(1);
 	});
 });
+
+describe("per-camera helper events", () => {
+	const unavailable = (i?: number) =>
+		`{"event":"warning","code":"webcam-unavailable"${i === undefined ? "" : `,"index":${i}`},"message":"x"}`;
+
+	it("collects unavailable cameras by index, an old event counting as camera 0", () => {
+		expect(readUnavailableWebcamIndices(`${unavailable(1)}\n${unavailable(3)}`)).toEqual([1, 3]);
+		expect(readUnavailableWebcamIndices(unavailable())).toEqual([0]);
+		expect(readUnavailableWebcamIndices("nothing")).toEqual([]);
+	});
+
+	it("ignores other warnings and reads a prefixed unavailable event", () => {
+		const other = '{"event":"warning","code":"microphone-defaulted","index":2}';
+		const prefixed = `INFO: camera lost ${unavailable(2)}`;
+		expect(readUnavailableWebcamIndices(`${other}\n${prefixed}`)).toEqual([2]);
+	});
+
+	it("reads the format of a given camera", () => {
+		const out = [
+			'{"event":"webcam-format","schemaVersion":2,"index":0,"width":1920,"height":1080,"fps":30,"deviceName":"A"}',
+			'{"event":"webcam-format","schemaVersion":2,"index":1,"width":1280,"height":720,"fps":30,"deviceName":"B"}',
+		].join("\n");
+		expect(readWebcamFormatAt(out, 1)?.width).toBe(1280);
+		expect(readWebcamFormatAt(out, 0)?.width).toBe(1920);
+		expect(readWebcamFormatAt(out, 2)).toBeNull();
+	});
+
+	it("reads a format event glued to a diagnostic prefix, the last one winning", () => {
+		const out = [
+			'INFO: DirectShow webcam connected subtype NV12 {"event":"webcam-format","index":1,"width":640,"height":480}',
+			'INFO: again {"event":"webcam-format","index":1,"width":1280,"height":720}',
+		].join("\n");
+		expect(readWebcamFormatAt(out, 1)?.width).toBe(1280);
+	});
+
+	it("treats a format without index as camera 0", () => {
+		expect(readWebcamFormatAt('{"event":"webcam-format","width":800}', 0)?.width).toBe(800);
+	});
+
+	it("reads every stopped camera path, falling back to the single legacy path", () => {
+		expect(
+			readStoppedWebcamPaths(
+				'{"event":"recording-stopped","webcamPath":"a.mp4","webcamPaths":["a.mp4","b.mp4"]}',
+			),
+		).toEqual(["a.mp4", "b.mp4"]);
+		expect(readStoppedWebcamPaths('{"event":"recording-stopped","webcamPath":"a.mp4"}')).toEqual([
+			"a.mp4",
+		]);
+		expect(readStoppedWebcamPaths('{"event":"recording-stopped"}')).toEqual([]);
+	});
+
+	it("reads JSON-escaped Windows paths behind a prefix", () => {
+		const line =
+			'INFO: x {"event":"recording-stopped","schemaVersion":2,"screenPath":"C:\\\\Users\\\\me\\\\s.mp4","webcamPath":"C:\\\\Users\\\\me\\\\s-webcam.mp4","webcamPaths":["C:\\\\Users\\\\me\\\\s-webcam.mp4","C:\\\\Users\\\\me\\\\s-webcam-2.mp4"]}';
+		expect(readStoppedWebcamPaths(line)).toEqual([
+			"C:\\Users\\me\\s-webcam.mp4",
+			"C:\\Users\\me\\s-webcam-2.mp4",
+		]);
+	});
+});
diff --git a/electron/recording/nativeWindowsCaptureStop.ts b/electron/recording/nativeWindowsCaptureStop.ts
index 478d30e61..824cf4b3c 100644
--- a/electron/recording/nativeWindowsCaptureStop.ts
+++ b/electron/recording/nativeWindowsCaptureStop.ts
@@ -218,6 +218,78 @@ export function readWebcamFormat(output: string) {
 	}
 }
 
+type HelperEvent = Record<string, unknown>;
+
+/**
+ * Every `{"event":"<name>"…}` object in the output, in order.
+ *
+ * Locates each object start and slices it with `findObjectEnd` instead of
+ * parsing whole lines, because diagnostics can be glued in front of an event
+ * (see `readWebcamFormat`). Slices that do not parse are skipped.
+ */
+function readHelperEvents(output: string, name: string): HelperEvent[] {
+	const needle = `{"event":"${name}"`;
+	const events: HelperEvent[] = [];
+	let from = 0;
+	for (;;) {
+		const start = output.indexOf(needle, from);
+		if (start === -1) {
+			return events;
+		}
+		const end = findObjectEnd(output, start);
+		if (end === -1) {
+			return events;
+		}
+		from = end + 1;
+		try {
+			const parsed: unknown = JSON.parse(output.slice(start, end + 1));
+			if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+				events.push(parsed as HelperEvent);
+			}
+		} catch {
+			// Not a complete JSON object; keep looking.
+		}
+	}
+}
+
+/** A helper event's camera index; an event without one comes from an old helper (camera 0). */
+function eventCameraIndex(event: HelperEvent) {
+	return typeof event.index === "number" ? event.index : 0;
+}
+
+/** Indices of every camera the helper reported as unavailable (no index = camera 0). */
+export function readUnavailableWebcamIndices(output: string): number[] {
+	return readHelperEvents(output, "warning")
+		.filter((event) => event.code === "webcam-unavailable")
+		.map(eventCameraIndex);
+}
+
+/** The last `webcam-format` event of the given camera (no index = camera 0), or null. */
+export function readWebcamFormatAt(
+	output: string,
+	index: number,
+): ReturnType<typeof readWebcamFormat> {
+	const match = readHelperEvents(output, "webcam-format")
+		.filter((event) => eventCameraIndex(event) === index)
+		.at(-1);
+	return (match as ReturnType<typeof readWebcamFormat>) ?? null;
+}
+
+/**
+ * Camera files the helper reported at stop: `webcamPaths`, else the single
+ * legacy `webcamPath`, else none.
+ */
+export function readStoppedWebcamPaths(output: string): string[] {
+	const event = readHelperEvents(output, "recording-stopped").at(-1);
+	if (!event) {
+		return [];
+	}
+	if (Array.isArray(event.webcamPaths)) {
+		return event.webcamPaths.filter((entry): entry is string => typeof entry === "string");
+	}
+	return typeof event.webcamPath === "string" && event.webcamPath ? [event.webcamPath] : [];
+}
+
 /**
  * The most useful line of a failed helper run, for a toast.
  *

From c0b235a87625ea6d7cefd0f3bed34cd995b4c10e Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 11:52:58 +0200
Subject: [PATCH 05/22] feat(recording): keep additional cameras in the session
 and media links

---
 electron/electron-env.d.ts                |  9 +--
 electron/ipc/handlers.ts                  | 84 +++++++++++++++++++----
 electron/media/mediaLinksRegistry.test.ts | 23 +++++++
 electron/media/mediaLinksRegistry.ts      | 18 ++++-
 src/lib/recordingSession.test.ts          | 56 +++++++++++++++
 src/lib/recordingSession.ts               | 46 +++++++++++++
 6 files changed, 216 insertions(+), 20 deletions(-)
 create mode 100644 src/lib/recordingSession.test.ts

diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.ts
index 26f2f5308..54e58e428 100644
--- a/electron/electron-env.d.ts
+++ b/electron/electron-env.d.ts
@@ -353,12 +353,9 @@ interface Window {
 			/** Why this recording ended before it was stopped, when it did. */
 			warning?: string;
 		}>;
-		findRecordingCamera: (videoPath: string) => Promise<{
-			success: boolean;
-			webcamVideoPath?: string;
-			offsetMs?: number;
-			error?: string;
-		}>;
+		findRecordingCamera: (
+			videoPath: string,
+		) => Promise<import("../src/lib/recordingSession").FindRecordingCameraResult>;
 		readBinaryFile: (filePath: string) => Promise<{
 			success: boolean;
 			data?: ArrayBuffer;
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index 81e706c08..4e93d8d12 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -34,7 +34,9 @@ import {
 } from "../../src/lib/nativeMacRecording";
 import type { NativeWindowsRecordingRequest } from "../../src/lib/nativeWindowsRecording";
 import {
+	type AdditionalWebcam,
 	type CursorCaptureMode,
+	type FindRecordingCameraResult,
 	normalizeCursorCaptureMode,
 	normalizeProjectMedia,
 	normalizeRecordingSession,
@@ -598,9 +600,25 @@ async function getApprovedProjectSession(
 		throw new Error("Project references an invalid or unsupported webcam video path");
 	}
 
-	return webcamVideoPath
-		? { screenVideoPath, webcamVideoPath, createdAt: Date.now() }
-		: { screenVideoPath, createdAt: Date.now() };
+	// Additional cameras go through the same approval as camera 1; one that no
+	// longer resolves is dropped rather than failing the whole project.
+	const additionalWebcams: AdditionalWebcam[] = [];
+	for (const extra of media.additionalWebcams ?? []) {
+		const approved = await approveReadableVideoPath(
+			await resolveWithSiblingFallback(extra.path),
+			trustedDirs,
+		);
+		if (approved) {
+			additionalWebcams.push({ path: approved, label: extra.label });
+		}
+	}
+
+	return {
+		screenVideoPath,
+		...(webcamVideoPath ? { webcamVideoPath } : {}),
+		...(additionalWebcams.length > 0 ? { additionalWebcams } : {}),
+		createdAt: Date.now(),
+	};
 }
 
 type SelectedSource = {
@@ -1341,6 +1359,7 @@ async function registerRecordingMediaLinks(
 	options: {
 		webcamVideoPath?: string;
 		webcamOffsetMs?: number;
+		additionalWebcams?: AdditionalWebcam[];
 		cursorCaptureMode?: CursorCaptureMode;
 	},
 ) {
@@ -1355,6 +1374,9 @@ async function registerRecordingMediaLinks(
 			...(options.webcamVideoPath && Number.isFinite(options.webcamOffsetMs)
 				? { webcamOffsetMs: options.webcamOffsetMs }
 				: {}),
+			...(options.additionalWebcams?.length
+				? { additionalWebcams: options.additionalWebcams }
+				: {}),
 			...(hasCursorTelemetry ? { cursorTelemetryPath } : {}),
 			...(options.cursorCaptureMode ? { cursorCaptureMode: options.cursorCaptureMode } : {}),
 		});
@@ -1792,10 +1814,34 @@ async function loadRecordedSessionForVideoPath(
 			}
 		}
 
+		if (session.additionalWebcams) {
+			const approvedExtras: AdditionalWebcam[] = [];
+			for (const extra of session.additionalWebcams) {
+				let extraPath: string | null = extra.path;
+				if (!isPathAllowed(extraPath)) {
+					extraPath = await approveReadableVideoPath(extraPath, [
+						path.dirname(manifestPath),
+						RECORDINGS_DIR,
+					]);
+				}
+				if (extraPath) {
+					approvedExtras.push({ path: extraPath, label: extra.label });
+				}
+			}
+			if (approvedExtras.length > 0) {
+				session.additionalWebcams = approvedExtras;
+			} else {
+				delete session.additionalWebcams;
+			}
+		}
+
 		approveFilePath(session.screenVideoPath);
 		if (session.webcamVideoPath) {
 			approveFilePath(session.webcamVideoPath);
 		}
+		for (const extra of session.additionalWebcams ?? []) {
+			approveFilePath(extra.path);
+		}
 		return session;
 	} catch (error) {
 		const nodeError = error as NodeJS.ErrnoException;
@@ -1815,6 +1861,7 @@ async function loadRecordedSessionForVideoPath(
 async function resolveMediaLinksForVideo(videoPath: string): Promise<{
 	webcamVideoPath?: string;
 	webcamOffsetMs?: number;
+	additionalWebcams?: AdditionalWebcam[];
 	cursorTelemetryPath?: string;
 	resolvedVia: "sidecar" | "fingerprint" | "none";
 }> {
@@ -1825,6 +1872,7 @@ async function resolveMediaLinksForVideo(videoPath: string): Promise<{
 		.then(() => true)
 		.catch(() => false);
 
+	const sessionAdditionalWebcams = session?.additionalWebcams ?? [];
 	if (session?.webcamVideoPath || hasCursorTelemetry) {
 		// Opportunistic backfill so the link survives a later move even if this
 		// recording predates the registry, or if its sidecar doesn't travel with it.
@@ -1833,6 +1881,9 @@ async function resolveMediaLinksForVideo(videoPath: string): Promise<{
 			...(session?.webcamVideoPath && Number.isFinite(session.webcamOffsetMs)
 				? { webcamOffsetMs: session.webcamOffsetMs }
 				: {}),
+			...(sessionAdditionalWebcams.length > 0
+				? { additionalWebcams: sessionAdditionalWebcams }
+				: {}),
 			...(hasCursorTelemetry ? { cursorTelemetryPath } : {}),
 		}).catch((error) => console.warn("[media-links] backfill failed:", error));
 
@@ -1843,6 +1894,9 @@ async function resolveMediaLinksForVideo(videoPath: string): Promise<{
 						webcamOffsetMs: session.webcamOffsetMs ?? 0,
 					}
 				: {}),
+			...(sessionAdditionalWebcams.length > 0
+				? { additionalWebcams: sessionAdditionalWebcams }
+				: {}),
 			...(hasCursorTelemetry ? { cursorTelemetryPath } : {}),
 			resolvedVia: "sidecar",
 		};
@@ -1856,8 +1910,19 @@ async function resolveMediaLinksForVideo(videoPath: string): Promise<{
 				webcamVideoPath =
 					(await approveReadableVideoPath(webcamVideoPath, [RECORDINGS_DIR])) ?? undefined;
 			}
+			const additionalWebcams: AdditionalWebcam[] = [];
+			for (const extra of links.additionalWebcams ?? []) {
+				let extraPath: string | null = extra.path;
+				if (!isPathAllowed(extraPath)) {
+					extraPath = await approveReadableVideoPath(extraPath, [RECORDINGS_DIR]);
+				}
+				if (extraPath) {
+					additionalWebcams.push({ path: extraPath, label: extra.label });
+				}
+			}
 			return {
 				...(webcamVideoPath ? { webcamVideoPath, webcamOffsetMs: links.webcamOffsetMs ?? 0 } : {}),
+				...(additionalWebcams.length > 0 ? { additionalWebcams } : {}),
 				...(links.cursorTelemetryPath ? { cursorTelemetryPath: links.cursorTelemetryPath } : {}),
 				resolvedVia: "fingerprint",
 			};
@@ -4727,15 +4792,7 @@ export function registerIpcHandlers(
 	// `addAsset` in the new editor's project store.
 	ipcMain.handle(
 		"find-recording-camera",
-		async (
-			_event,
-			videoPath: string,
-		): Promise<{
-			success: boolean;
-			webcamVideoPath?: string;
-			offsetMs?: number;
-			error?: string;
-		}> => {
+		async (_event, videoPath: string): Promise<FindRecordingCameraResult> => {
 			try {
 				const normalized = normalizeVideoSourcePath(videoPath);
 				if (!normalized || !isPathAllowed(normalized)) {
@@ -4749,6 +4806,9 @@ export function registerIpcHandlers(
 					success: true,
 					webcamVideoPath: resolution.webcamVideoPath,
 					offsetMs: resolution.webcamOffsetMs ?? 0,
+					...(resolution.additionalWebcams?.length
+						? { additionalWebcams: resolution.additionalWebcams }
+						: {}),
 				};
 			} catch (err) {
 				return {
diff --git a/electron/media/mediaLinksRegistry.test.ts b/electron/media/mediaLinksRegistry.test.ts
index 7c76a7580..0aae45269 100644
--- a/electron/media/mediaLinksRegistry.test.ts
+++ b/electron/media/mediaLinksRegistry.test.ts
@@ -187,6 +187,29 @@ describe("mediaLinksRegistry", () => {
 			}
 		});
 
+		it("round-trips additional cameras and resolves old records without them", async () => {
+			const screenPath = path.join(tempDir, "multi.webm");
+			const oldScreenPath = path.join(tempDir, "old.webm");
+			await writeFileOfSize(screenPath, 5000, "m");
+			await writeFileOfSize(oldScreenPath, 5000, "o");
+			const additionalWebcams = [
+				{ path: path.join(tempDir, "multi-webcam-2.mp4"), label: "Desk" },
+				{ path: path.join(tempDir, "multi-webcam-3.mp4"), label: "" },
+			];
+			await registerMediaLinks(tempDir, screenPath, {
+				webcamVideoPath: path.join(tempDir, "multi-webcam.mp4"),
+				additionalWebcams,
+			});
+			await registerMediaLinks(tempDir, oldScreenPath, {
+				webcamVideoPath: path.join(tempDir, "old-webcam.mp4"),
+			});
+
+			const resolved = await findMediaLinksByFingerprint(tempDir, screenPath);
+			expect(resolved?.additionalWebcams).toEqual(additionalWebcams);
+			const old = await findMediaLinksByFingerprint(tempDir, oldScreenPath);
+			expect(old).not.toHaveProperty("additionalWebcams");
+		});
+
 		it("returns null when there is no matching fingerprint", async () => {
 			const unknownPath = path.join(tempDir, "unknown.webm");
 			await writeFileOfSize(unknownPath, 1000, "z");
diff --git a/electron/media/mediaLinksRegistry.ts b/electron/media/mediaLinksRegistry.ts
index ec0ad76de..69d119d51 100644
--- a/electron/media/mediaLinksRegistry.ts
+++ b/electron/media/mediaLinksRegistry.ts
@@ -19,7 +19,11 @@
 
 import fs from "node:fs/promises";
 import path from "node:path";
-import type { CursorCaptureMode } from "../../src/lib/recordingSession";
+import {
+	type AdditionalWebcam,
+	type CursorCaptureMode,
+	normalizeAdditionalWebcams,
+} from "../../src/lib/recordingSession";
 
 // ponytail: `baseDir` is passed in by every caller (RECORDINGS_DIR in
 // electron/ipc/handlers.ts) rather than imported here, so this module has no
@@ -40,6 +44,7 @@ export interface MediaLinkEntry {
 	fingerprint: MediaFingerprint;
 	webcamVideoPath?: string;
 	webcamOffsetMs?: number;
+	additionalWebcams?: AdditionalWebcam[];
 	cursorTelemetryPath?: string;
 	cursorCaptureMode?: CursorCaptureMode;
 	updatedAt: string;
@@ -98,6 +103,7 @@ function normalizeEntry(candidate: unknown): MediaLinkEntry | null {
 	if (!candidate || typeof candidate !== "object") return null;
 	const raw = candidate as Partial<MediaLinkEntry>;
 	const fp = raw.fingerprint;
+	const additionalWebcams = normalizeAdditionalWebcams(raw.additionalWebcams);
 	if (
 		typeof raw.lastKnownPath !== "string" ||
 		!fp ||
@@ -116,6 +122,7 @@ function normalizeEntry(candidate: unknown): MediaLinkEntry | null {
 		},
 		...(typeof raw.webcamVideoPath === "string" ? { webcamVideoPath: raw.webcamVideoPath } : {}),
 		...(typeof raw.webcamOffsetMs === "number" ? { webcamOffsetMs: raw.webcamOffsetMs } : {}),
+		...(additionalWebcams.length > 0 ? { additionalWebcams } : {}),
 		...(typeof raw.cursorTelemetryPath === "string"
 			? { cursorTelemetryPath: raw.cursorTelemetryPath }
 			: {}),
@@ -220,6 +227,7 @@ async function updateRegistry(
 export interface MediaLinksToRegister {
 	webcamVideoPath?: string;
 	webcamOffsetMs?: number;
+	additionalWebcams?: AdditionalWebcam[];
 	cursorTelemetryPath?: string;
 	cursorCaptureMode?: CursorCaptureMode;
 }
@@ -236,6 +244,8 @@ export async function registerMediaLinks(
 	links: MediaLinksToRegister,
 ): Promise<void> {
 	if (!links.webcamVideoPath && !links.cursorTelemetryPath) return;
+	const { additionalWebcams: rawAdditionalWebcams, ...linksWithoutAdditional } = links;
+	const additionalWebcams = normalizeAdditionalWebcams(rawAdditionalWebcams);
 	const fingerprint = await computeFingerprint(videoPath);
 	await updateRegistry(baseDir, (file) => {
 		const existingIndex = file.entries.findIndex((e) =>
@@ -244,7 +254,8 @@ export async function registerMediaLinks(
 		const entry: MediaLinkEntry = {
 			lastKnownPath: videoPath,
 			fingerprint,
-			...links,
+			...linksWithoutAdditional,
+			...(additionalWebcams.length > 0 ? { additionalWebcams } : {}),
 			updatedAt: new Date().toISOString(),
 		};
 		const entries =
@@ -258,6 +269,7 @@ export async function registerMediaLinks(
 export interface MediaLinksLookup {
 	webcamVideoPath?: string;
 	webcamOffsetMs?: number;
+	additionalWebcams?: AdditionalWebcam[];
 	cursorTelemetryPath?: string;
 	cursorCaptureMode?: CursorCaptureMode;
 }
@@ -314,6 +326,7 @@ export async function findRelocatedMediaByStoredPath(
 		screenVideoPath: match.lastKnownPath,
 		...(match.webcamVideoPath ? { webcamVideoPath: match.webcamVideoPath } : {}),
 		...(typeof match.webcamOffsetMs === "number" ? { webcamOffsetMs: match.webcamOffsetMs } : {}),
+		...(match.additionalWebcams?.length ? { additionalWebcams: match.additionalWebcams } : {}),
 		...(match.cursorTelemetryPath ? { cursorTelemetryPath: match.cursorTelemetryPath } : {}),
 		...(match.cursorCaptureMode ? { cursorCaptureMode: match.cursorCaptureMode } : {}),
 	};
@@ -358,6 +371,7 @@ export async function findMediaLinksByFingerprint(
 	return {
 		...(match.webcamVideoPath ? { webcamVideoPath: match.webcamVideoPath } : {}),
 		...(typeof match.webcamOffsetMs === "number" ? { webcamOffsetMs: match.webcamOffsetMs } : {}),
+		...(match.additionalWebcams?.length ? { additionalWebcams: match.additionalWebcams } : {}),
 		...(match.cursorTelemetryPath ? { cursorTelemetryPath: match.cursorTelemetryPath } : {}),
 		...(match.cursorCaptureMode ? { cursorCaptureMode: match.cursorCaptureMode } : {}),
 	};
diff --git a/src/lib/recordingSession.test.ts b/src/lib/recordingSession.test.ts
new file mode 100644
index 000000000..8ca842b0d
--- /dev/null
+++ b/src/lib/recordingSession.test.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { normalizeProjectMedia, normalizeRecordingSession } from "./recordingSession";
+
+describe("additionalWebcams", () => {
+	it("normalizes a session without additionalWebcams unchanged", () => {
+		expect(normalizeProjectMedia({ screenVideoPath: "/s.mp4", webcamVideoPath: "/w.mp4" })).toEqual(
+			{
+				screenVideoPath: "/s.mp4",
+				webcamVideoPath: "/w.mp4",
+			},
+		);
+	});
+	it("keeps valid entries in order", () => {
+		const media = normalizeProjectMedia({
+			screenVideoPath: "/s.mp4",
+			additionalWebcams: [
+				{ path: " /w-2.mp4 ", label: "Desk" },
+				{ path: "/w-3.mp4", label: "Side" },
+			],
+		});
+		expect(media?.additionalWebcams).toEqual([
+			{ path: "/w-2.mp4", label: "Desk" },
+			{ path: "/w-3.mp4", label: "Side" },
+		]);
+	});
+	it("drops invalid additionalWebcams entries and caps the list", () => {
+		const media = normalizeProjectMedia({
+			screenVideoPath: "/s.mp4",
+			additionalWebcams: [
+				{ path: "", label: "x" },
+				{ label: "no path" },
+				"junk",
+				{ path: "/a.mp4" },
+				{ path: "/b.mp4", label: "B" },
+				{ path: "/c.mp4", label: "C" },
+				{ path: "/d.mp4", label: "D" },
+			],
+		});
+		expect(media?.additionalWebcams).toEqual([
+			{ path: "/a.mp4", label: "" },
+			{ path: "/b.mp4", label: "B" },
+			{ path: "/c.mp4", label: "C" },
+		]);
+		expect(
+			normalizeProjectMedia({ screenVideoPath: "/s.mp4", additionalWebcams: [] }),
+		).not.toHaveProperty("additionalWebcams");
+	});
+	it("survives a session round trip", () => {
+		const session = normalizeRecordingSession({
+			screenVideoPath: "/s.mp4",
+			createdAt: 1,
+			additionalWebcams: [{ path: "/w-2.mp4", label: "Desk" }],
+		});
+		expect(normalizeRecordingSession(JSON.parse(JSON.stringify(session)))).toEqual(session);
+	});
+});
diff --git a/src/lib/recordingSession.ts b/src/lib/recordingSession.ts
index 5fd06bc25..2da7603af 100644
--- a/src/lib/recordingSession.ts
+++ b/src/lib/recordingSession.ts
@@ -1,3 +1,12 @@
+/** A recorded camera beyond camera 1 (which stays `webcamVideoPath`). */
+export interface AdditionalWebcam {
+	path: string;
+	label: string;
+}
+
+/** Camera 1 plus at most this many additional cameras (4 in total). */
+export const MAX_ADDITIONAL_WEBCAMS = 3;
+
 export interface ProjectMedia {
 	screenVideoPath: string;
 	webcamVideoPath?: string;
@@ -10,6 +19,8 @@ export interface ProjectMedia {
 	 * that much extra leading footage instead of showing stale camera frames.
 	 */
 	webcamOffsetMs?: number;
+	/** Cameras 2-4, in recording order. Omitted when there are none. */
+	additionalWebcams?: AdditionalWebcam[];
 	cursorCaptureMode?: CursorCaptureMode;
 }
 
@@ -53,6 +64,29 @@ function normalizePath(value: unknown): string | undefined {
 	return trimmed ? trimmed : undefined;
 }
 
+export function normalizeAdditionalWebcams(value: unknown): AdditionalWebcam[] {
+	if (!Array.isArray(value)) {
+		return [];
+	}
+
+	const result: AdditionalWebcam[] = [];
+	for (const entry of value) {
+		if (result.length >= MAX_ADDITIONAL_WEBCAMS) {
+			break;
+		}
+		if (!entry || typeof entry !== "object") {
+			continue;
+		}
+		const raw = entry as Partial<AdditionalWebcam>;
+		const entryPath = normalizePath(raw.path);
+		if (!entryPath) {
+			continue;
+		}
+		result.push({ path: entryPath, label: typeof raw.label === "string" ? raw.label : "" });
+	}
+	return result;
+}
+
 export function normalizeProjectMedia(candidate: unknown): ProjectMedia | null {
 	if (!candidate || typeof candidate !== "object") {
 		return null;
@@ -66,6 +100,7 @@ export function normalizeProjectMedia(candidate: unknown): ProjectMedia | null {
 	}
 
 	const webcamVideoPath = normalizePath(raw.webcamVideoPath);
+	const additionalWebcams = normalizeAdditionalWebcams(raw.additionalWebcams);
 	const cursorCaptureMode = normalizeCursorCaptureMode(raw.cursorCaptureMode);
 	const webcamOffsetMs =
 		typeof raw.webcamOffsetMs === "number" && Number.isFinite(raw.webcamOffsetMs)
@@ -76,6 +111,7 @@ export function normalizeProjectMedia(candidate: unknown): ProjectMedia | null {
 		screenVideoPath,
 		...(webcamVideoPath ? { webcamVideoPath } : {}),
 		...(webcamOffsetMs !== undefined ? { webcamOffsetMs } : {}),
+		...(additionalWebcams.length > 0 ? { additionalWebcams } : {}),
 		...(cursorCaptureMode ? { cursorCaptureMode } : {}),
 	};
 }
@@ -99,3 +135,13 @@ export function normalizeRecordingSession(candidate: unknown): RecordingSession
 				: Date.now(),
 	};
 }
+
+/** Result of the `find-recording-camera` IPC, shared by the handler and the renderer typing. */
+export interface FindRecordingCameraResult {
+	success: boolean;
+	webcamVideoPath?: string;
+	offsetMs?: number;
+	/** Cameras 2-4 of the same recording, already approved for reading. */
+	additionalWebcams?: AdditionalWebcam[];
+	error?: string;
+}

From 1dead65f84c2a80cdc34ce06517b65d35f7d9d76 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 12:01:42 +0200
Subject: [PATCH 06/22] feat(recording): start and stop several cameras on
 Windows

---
 electron/electron-env.d.ts                    |   5 +
 electron/ipc/handlers.ts                      | 199 ++++++++++++-----
 .../recording/nativeWindowsWebcams.test.ts    | 179 ++++++++++++++++
 electron/recording/nativeWindowsWebcams.ts    | 202 ++++++++++++++++++
 src/lib/nativeWindowsRecording.ts             |  10 +
 5 files changed, 545 insertions(+), 50 deletions(-)
 create mode 100644 electron/recording/nativeWindowsWebcams.test.ts
 create mode 100644 electron/recording/nativeWindowsWebcams.ts

diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.ts
index 54e58e428..f0ed35c2f 100644
--- a/electron/electron-env.d.ts
+++ b/electron/electron-env.d.ts
@@ -177,6 +177,11 @@ interface Window {
 			 * saved without it. Still a success — the screen video is intact.
 			 */
 			webcamDropped?: boolean;
+			/**
+			 * Device names of additional cameras (2-4) that produced nothing usable
+			 * and were left out of the session. Camera 1 is `webcamDropped`.
+			 */
+			droppedWebcams?: string[];
 		}>;
 		pauseNativeWindowsRecording: () => Promise<{
 			success: boolean;
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index 4e93d8d12..835a7a231 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -124,11 +124,21 @@ import {
 	readMicrophoneDefaulted,
 	readMicrophoneUnavailable,
 	readSecondaryWindowsApplied,
-	readWebcamFormat,
-	readWebcamUnavailable,
+	readStoppedWebcamPaths,
+	readUnavailableWebcamIndices,
+	readWebcamFormatAt,
 	terminateNativeWindowsCapture,
 	waitForNativeWindowsCaptureStop,
 } from "../recording/nativeWindowsCaptureStop";
+import {
+	buildHelperWebcamConfig,
+	collectStoppedWebcams,
+	dedupeAdditionalWebcams,
+	isWebcamSidecarFile,
+	labelsOfUnavailableAdditionalWebcams,
+	stripWebcamSuffix,
+	webcamOutputPath,
+} from "../recording/nativeWindowsWebcams";
 import { patchWebmDurationOnDisk } from "../recording/webm-duration";
 import { reindexRecordingOnDisk } from "../recording/webm-seek-index";
 import {
@@ -744,6 +754,11 @@ let nativeWindowsCaptureProcess: ChildProcessWithoutNullStreams | null = null;
 let nativeWindowsCaptureOutput = "";
 let nativeWindowsCaptureTargetPath: string | null = null;
 let nativeWindowsCaptureWebcamTargetPath: string | null = null;
+/**
+ * Cameras 2-4 of the running take, in helper order after camera 1, each with
+ * the label it is reported under. Only paths generated here ever land in it.
+ */
+let nativeWindowsCaptureAdditionalWebcamTargets: Array<{ path: string; label: string }> = [];
 let nativeWindowsCaptureRecordingId: number | null = null;
 let nativeWindowsCursorOffsetMs = 0;
 let nativeWindowsCursorCaptureMode: CursorCaptureMode = "editable-overlay";
@@ -770,6 +785,7 @@ function resetNativeWindowsCaptureState() {
 	nativeWindowsCaptureProcess = null;
 	nativeWindowsCaptureTargetPath = null;
 	nativeWindowsCaptureWebcamTargetPath = null;
+	nativeWindowsCaptureAdditionalWebcamTargets = [];
 	nativeWindowsCaptureRecordingId = null;
 	nativeWindowsCursorOffsetMs = 0;
 	nativeWindowsCursorCaptureMode = "editable-overlay";
@@ -797,12 +813,12 @@ async function salvageNativeWindowsFragmentedCapture(screenVideoPath: string | n
  */
 async function removeNativeWindowsCaptureOutputs(
 	screenVideoPath: string | null,
-	webcamVideoPath: string | null,
+	webcamVideoPaths: Array<string | null>,
 	options: { onlyIfUnusable?: boolean } = {},
 ) {
 	const targets = [
 		screenVideoPath,
-		webcamVideoPath,
+		...webcamVideoPaths,
 		screenVideoPath ? `${screenVideoPath}.cursor.json` : null,
 	];
 
@@ -1758,9 +1774,7 @@ function setCurrentRecordingSessionState(session: RecordingSession | null) {
 
 function getSessionManifestPathForVideo(videoPath: string) {
 	const parsedPath = path.parse(videoPath);
-	const baseName = parsedPath.name.endsWith("-webcam")
-		? parsedPath.name.slice(0, -"-webcam".length)
-		: parsedPath.name;
+	const baseName = stripWebcamSuffix(parsedPath.name);
 	return path.join(parsedPath.dir, `${baseName}${RECORDING_SESSION_SUFFIX}`);
 }
 
@@ -2856,10 +2870,7 @@ export function registerIpcHandlers(
 						? request.recordingId
 						: Date.now();
 				const outputPath = path.join(RECORDINGS_DIR, `${RECORDING_FILE_PREFIX}${recordingId}.mp4`);
-				const webcamOutputPath = path.join(
-					RECORDINGS_DIR,
-					`${RECORDING_FILE_PREFIX}${recordingId}-webcam.mp4`,
-				);
+				const webcamPath = webcamOutputPath(RECORDINGS_DIR, RECORDING_FILE_PREFIX, recordingId, 1);
 				const sourceDisplay =
 					request.source.type === "display" && typeof request.source.displayId === "number"
 						? (screen.getAllDisplays().find((display) => display.id === request.source.displayId) ??
@@ -2878,6 +2889,22 @@ export function registerIpcHandlers(
 				const webcamDirectShowClsid = request.webcam.enabled
 					? await resolveDirectShowWebcamClsid(request.webcam.deviceName)
 					: null;
+				// Cameras 2-4 only while camera 1 is on: its toggle governs every
+				// camera. Files are numbered from 2 in the order they are sent.
+				const additionalWebcams = request.webcam.enabled
+					? await Promise.all(
+							dedupeAdditionalWebcams(
+								request.webcam,
+								Array.isArray(request.additionalWebcams) ? request.additionalWebcams : [],
+							).map(async (extra, i) => ({
+								deviceId: extra.deviceId,
+								deviceName: extra.deviceName,
+								label: extra.deviceName?.trim() || `Camera ${i + 2}`,
+								clsid: await resolveDirectShowWebcamClsid(extra.deviceName),
+								path: webcamOutputPath(RECORDINGS_DIR, RECORDING_FILE_PREFIX, recordingId, i + 2),
+							})),
+						)
+					: [];
 				const cursorCaptureMode =
 					normalizeCursorCaptureMode(request.cursor?.mode) ?? "editable-overlay";
 				const envPreferSoftwareEncoder = (process.env.OPENSCREEN_WGC_PREFER_SOFTWARE_ENCODER ?? "")
@@ -2909,13 +2936,12 @@ export function registerIpcHandlers(
 					microphoneDeviceId: request.audio.microphone.deviceId ?? null,
 					microphoneDeviceName: request.audio.microphone.deviceName ?? null,
 					microphoneGain: request.audio.microphone.gain,
-					webcamEnabled: request.webcam.enabled,
-					webcamDeviceId: request.webcam.deviceId ?? null,
-					webcamDeviceName: request.webcam.deviceName ?? null,
-					webcamDirectShowClsid,
-					webcamWidth: request.webcam.width,
-					webcamHeight: request.webcam.height,
-					webcamFps: request.webcam.fps,
+					...buildHelperWebcamConfig({
+						camera1: request.webcam,
+						camera1Clsid: webcamDirectShowClsid,
+						camera1Path: webcamPath,
+						extras: additionalWebcams,
+					}),
 					captureCursor: cursorCaptureMode === "system",
 					cursorCaptureMode,
 					hideDesktopIcons:
@@ -2923,7 +2949,7 @@ export function registerIpcHandlers(
 						appSettings.getSnapshot().recording.hideDesktopIcons,
 					outputs: {
 						screenPath: outputPath,
-						webcamPath: webcamOutputPath,
+						webcamPath,
 					},
 					source: {
 						type: request.source.type,
@@ -2945,6 +2971,10 @@ export function registerIpcHandlers(
 					source: request.source,
 					audio: request.audio,
 					webcam: request.webcam,
+					additionalWebcams: additionalWebcams.map(({ label, path: cameraPath }) => ({
+						label,
+						path: cameraPath,
+					})),
 					encoder: { preferSoftwareEncoder },
 					cursor: { mode: cursorCaptureMode },
 					// Both spaces, deliberately: the helper's own errors quote the physical
@@ -2959,7 +2989,10 @@ export function registerIpcHandlers(
 				await fs.mkdir(RECORDINGS_DIR, { recursive: true });
 				nativeWindowsCaptureOutput = "";
 				nativeWindowsCaptureTargetPath = outputPath;
-				nativeWindowsCaptureWebcamTargetPath = request.webcam.enabled ? webcamOutputPath : null;
+				nativeWindowsCaptureWebcamTargetPath = request.webcam.enabled ? webcamPath : null;
+				nativeWindowsCaptureAdditionalWebcamTargets = additionalWebcams.map(
+					({ label, path: cameraPath }) => ({ label, path: cameraPath }),
+				);
 				nativeWindowsCaptureRecordingId = recordingId;
 				nativeWindowsCursorOffsetMs = 0;
 				nativeWindowsCursorCaptureMode = cursorCaptureMode;
@@ -2995,7 +3028,13 @@ export function registerIpcHandlers(
 					cursorCaptureMode === "editable-overlay"
 						? Math.max(0, captureStartedAtMs - cursorStartTimeMs)
 						: 0;
-				const webcamFormat = readWebcamFormat(nativeWindowsCaptureOutput);
+				// Index-aware readers: with several cameras the helper prints one
+				// format line and possibly one unavailable warning per camera, and
+				// only index 0 (or no index, from an old helper) is camera 1.
+				const webcamFormat = readWebcamFormatAt(nativeWindowsCaptureOutput, 0);
+				const unavailableWebcamIndices = new Set(
+					readUnavailableWebcamIndices(nativeWindowsCaptureOutput),
+				);
 				const encoderSelection = readNativeWindowsEncoderSelection(nativeWindowsCaptureOutput);
 				// Captured now because stop may have no helper left to ask. A helper
 				// killed mid-recording is exactly the case where this matters most.
@@ -3004,6 +3043,9 @@ export function registerIpcHandlers(
 					captureStartedAtMs,
 					cursorOffsetMs: nativeWindowsCursorOffsetMs,
 					webcamFormat,
+					additionalWebcamFormats: nativeWindowsCaptureAdditionalWebcamTargets.map((_, i) =>
+						readWebcamFormatAt(nativeWindowsCaptureOutput, i + 1),
+					),
 					encoderSelection,
 					// Logged only: menus missing from a window take on Windows before 11
 					// 24H2 are a platform limit, not something to put in front of the user.
@@ -3023,8 +3065,7 @@ export function registerIpcHandlers(
 				// missing `webcamFormat`: absence of the format line also means "the
 				// line could not be parsed", which would put a red toast on a recording
 				// whose camera is working perfectly.
-				const webcamUnavailable =
-					request.webcam.enabled && readWebcamUnavailable(nativeWindowsCaptureOutput);
+				const webcamUnavailable = request.webcam.enabled && unavailableWebcamIndices.has(0);
 				// Same shape as the camera notice: the helper records the Windows
 				// default input rather than failing, so this take is usable but is
 				// almost certainly the wrong microphone.
@@ -3042,6 +3083,28 @@ export function registerIpcHandlers(
 						deviceName: request.webcam.deviceName,
 					});
 				}
+				// Helper indices follow the `webcams` list: camera 1 at 0, extras after.
+				const startedWebcams = [
+					{ path: webcamPath, label: request.webcam.deviceName ?? "" },
+					...nativeWindowsCaptureAdditionalWebcamTargets,
+				];
+				const unavailableWebcams = request.webcam.enabled
+					? labelsOfUnavailableAdditionalWebcams(startedWebcams, [...unavailableWebcamIndices])
+					: [];
+				if (unavailableWebcams.length > 0) {
+					console.warn(
+						"[native-wgc] recording without additional cameras the helper could not open",
+						{
+							unavailableWebcams,
+						},
+					);
+					// Already reported now; the helper deleted their files, so leaving
+					// them in the targets would report them a second time at stop.
+					nativeWindowsCaptureAdditionalWebcamTargets =
+						nativeWindowsCaptureAdditionalWebcamTargets.filter(
+							(_, i) => !unavailableWebcamIndices.has(i + 1),
+						);
+				}
 
 				return {
 					success: true,
@@ -3051,6 +3114,7 @@ export function registerIpcHandlers(
 					videoEncoderSelection: encoderSelection?.video ?? null,
 					videoEncoderRuntime: encoderSelection?.videoEncoderRuntime ?? null,
 					webcamUnavailable,
+					...(unavailableWebcams.length > 0 ? { unavailableWebcams } : {}),
 					microphoneDefaulted,
 				};
 			} catch (error) {
@@ -3386,6 +3450,11 @@ export function registerIpcHandlers(
 		const proc = nativeWindowsCaptureProcess;
 		const preferredPath = nativeWindowsCaptureTargetPath;
 		const preferredWebcamPath = nativeWindowsCaptureWebcamTargetPath;
+		const additionalWebcamTargets = nativeWindowsCaptureAdditionalWebcamTargets;
+		const allWebcamPaths = [
+			preferredWebcamPath,
+			...additionalWebcamTargets.map((target) => target.path),
+		];
 		const recordingId = nativeWindowsCaptureRecordingId ?? Date.now();
 		const cursorCaptureMode = nativeWindowsCursorCaptureMode;
 
@@ -3408,7 +3477,7 @@ export function registerIpcHandlers(
 				if (!exited) {
 					detachNativeWindowsCaptureOutputDrain();
 				}
-				await removeNativeWindowsCaptureOutputs(preferredPath, preferredWebcamPath);
+				await removeNativeWindowsCaptureOutputs(preferredPath, allWebcamPaths);
 				return { success: true, discarded: true };
 			} finally {
 				// Unconditional. Killing a wedged helper can itself throw, and
@@ -3482,7 +3551,7 @@ export function registerIpcHandlers(
 					// explain. Size-gate it anyway: throwing away a recording to tidy
 					// up after a failed stop is the worse mistake of the two, and the
 					// gate is the same one the salvage check above uses.
-					await removeNativeWindowsCaptureOutputs(preferredPath, preferredWebcamPath, {
+					await removeNativeWindowsCaptureOutputs(preferredPath, allWebcamPaths, {
 						onlyIfUnusable: true,
 					});
 					// The helper log goes to console/diagnostics above, not into this
@@ -3518,31 +3587,56 @@ export function registerIpcHandlers(
 				shiftPendingCursorTelemetry(nativeWindowsCursorOffsetMs);
 				await writePendingCursorTelemetry(screenVideoPath);
 			}
-			let webcamVideoPath: string | undefined;
-			if (preferredWebcamPath) {
-				try {
-					// Size, not just existence. A camera that opened but delivered no
-					// frame still gets a file created for it, and its `Finalize()` then
-					// fails, leaving nought bytes on disk. Admitting that file put a
-					// camera track in the document pointing at something no demuxer can
-					// read, and the preview compositor answers an unreadable camera by
-					// drawing the SCREEN recording inside the little camera rectangle —
-					// which is how a webcam that never recorded showed up as the desktop
-					// duplicated into its own corner (getopenscreen/openscreen#387).
-					const webcamStat = await fs.stat(preferredWebcamPath);
-					webcamVideoPath = webcamStat.size > 0 ? preferredWebcamPath : undefined;
-					if (!webcamVideoPath) {
-						console.warn("[native-wgc] the webcam file is empty; saving without a camera", {
-							path: preferredWebcamPath,
-						});
-					}
-				} catch {
-					webcamVideoPath = undefined;
+			// Size, not just existence. A camera that opened but delivered no frame
+			// still gets a file created for it, and its `Finalize()` then fails,
+			// leaving nought bytes on disk. Admitting that file put a camera track in
+			// the document pointing at something no demuxer can read, and the preview
+			// compositor answers an unreadable camera by drawing the SCREEN recording
+			// inside the little camera rectangle — which is how a webcam that never
+			// recorded showed up as the desktop duplicated into its own corner
+			// (getopenscreen/openscreen#387). Every camera is judged by its own file,
+			// not by the helper's list at stop (see `collectStoppedWebcams`).
+			const requestedWebcams = [
+				...(preferredWebcamPath ? [{ path: preferredWebcamPath, label: "" }] : []),
+				...additionalWebcamTargets,
+			];
+			const webcamSizes = new Map<string, number>();
+			for (const camera of requestedWebcams) {
+				const stat = await fs.stat(camera.path).catch(() => null);
+				if (stat) {
+					webcamSizes.set(camera.path, stat.size);
 				}
 			}
-			const session: RecordingSession = webcamVideoPath
-				? { screenVideoPath, webcamVideoPath, createdAt: recordingId, cursorCaptureMode }
-				: { screenVideoPath, createdAt: recordingId, cursorCaptureMode };
+			const stoppedWebcams = collectStoppedWebcams({
+				camera1Enabled: Boolean(preferredWebcamPath),
+				requested: requestedWebcams,
+				sizes: webcamSizes,
+			});
+			const webcamVideoPath = stoppedWebcams.camera1;
+			const additionalWebcams = stoppedWebcams.additional;
+			if (preferredWebcamPath && !webcamVideoPath && webcamSizes.has(preferredWebcamPath)) {
+				console.warn("[native-wgc] the webcam file is empty; saving without a camera", {
+					path: preferredWebcamPath,
+				});
+			}
+			if (stoppedWebcams.dropped.length > 0) {
+				console.warn("[native-wgc] additional cameras produced nothing usable", {
+					dropped: stoppedWebcams.dropped,
+					helperWebcamPaths: readStoppedWebcamPaths(nativeWindowsCaptureOutput),
+				});
+			}
+			// Generated by the start handler, never taken from the renderer or the
+			// helper; approved like the session's other media.
+			for (const extra of additionalWebcams) {
+				approveFilePath(extra.path);
+			}
+			const session: RecordingSession = {
+				screenVideoPath,
+				...(webcamVideoPath ? { webcamVideoPath } : {}),
+				...(additionalWebcams.length > 0 ? { additionalWebcams } : {}),
+				createdAt: recordingId,
+				cursorCaptureMode,
+			};
 			setCurrentRecordingSessionState(session);
 			currentProjectPath = null;
 
@@ -3551,7 +3645,11 @@ export function registerIpcHandlers(
 				`${path.parse(screenVideoPath).name}${RECORDING_SESSION_SUFFIX}`,
 			);
 			await fs.writeFile(sessionManifestPath, JSON.stringify(session, null, 2), "utf-8");
-			await registerRecordingMediaLinks(screenVideoPath, { webcamVideoPath, cursorCaptureMode });
+			await registerRecordingMediaLinks(screenVideoPath, {
+				webcamVideoPath,
+				...(additionalWebcams.length > 0 ? { additionalWebcams } : {}),
+				cursorCaptureMode,
+			});
 
 			return {
 				success: true,
@@ -3566,6 +3664,7 @@ export function registerIpcHandlers(
 				// unreported, the user would find out in the editor — which is exactly
 				// the silence this change exists to end.
 				webcamDropped: Boolean(preferredWebcamPath) && !webcamVideoPath,
+				...(stoppedWebcams.dropped.length > 0 ? { droppedWebcams: stoppedWebcams.dropped } : {}),
 				message: recovered
 					? "Native Windows recording recovered from a failed stop"
 					: "Native Windows recording session stored successfully",
@@ -4034,7 +4133,7 @@ export function registerIpcHandlers(
 
 			const files = await fs.readdir(RECORDINGS_DIR);
 			const videoFiles = files.filter(
-				(file) => file.endsWith(".webm") && !file.endsWith("-webcam.webm"),
+				(file) => file.endsWith(".webm") && !isWebcamSidecarFile(file),
 			);
 
 			if (videoFiles.length === 0) {
diff --git a/electron/recording/nativeWindowsWebcams.test.ts b/electron/recording/nativeWindowsWebcams.test.ts
new file mode 100644
index 000000000..bb4e7c039
--- /dev/null
+++ b/electron/recording/nativeWindowsWebcams.test.ts
@@ -0,0 +1,179 @@
+import { describe, expect, it } from "vitest";
+import {
+	buildHelperWebcamConfig,
+	collectStoppedWebcams,
+	dedupeAdditionalWebcams,
+	isWebcamSidecarFile,
+	labelsOfUnavailableAdditionalWebcams,
+	stripWebcamSuffix,
+	webcamOutputPath,
+} from "./nativeWindowsWebcams";
+
+describe("nativeWindowsWebcams", () => {
+	it("names camera files", () => {
+		expect(webcamOutputPath("C:\\r", "rec-", 7, 1)).toMatch(/rec-7-webcam\.mp4$/);
+		expect(webcamOutputPath("C:\\r", "rec-", 7, 3)).toMatch(/rec-7-webcam-3\.mp4$/);
+	});
+
+	it("recognizes every camera file of a recording and nothing else", () => {
+		for (const f of ["rec-7-webcam.mp4", "rec-7-webcam-2.mp4", "rec-7-webcam-4.webm"]) {
+			expect(isWebcamSidecarFile(f)).toBe(true);
+		}
+		for (const f of ["rec-7.mp4", "rec-7-webcamera.mp4", "rec-7-webcam-x.mp4"]) {
+			expect(isWebcamSidecarFile(f)).toBe(false);
+		}
+		expect(stripWebcamSuffix("rec-7-webcam-2")).toBe("rec-7");
+		expect(stripWebcamSuffix("rec-7-webcam")).toBe("rec-7");
+		expect(stripWebcamSuffix("rec-7")).toBe("rec-7");
+	});
+
+	it("dedupes a device that equals camera 1, duplicates, and caps at three", () => {
+		const extras = [
+			{ deviceId: "a", deviceName: "Front" },
+			{ deviceId: "b", deviceName: "Desk" },
+			{ deviceId: "b", deviceName: "Desk" },
+			{ deviceName: "Side" },
+			{ deviceName: "Top" },
+			{ deviceName: "Fifth" },
+		];
+		expect(
+			dedupeAdditionalWebcams({ deviceId: "a", deviceName: "Front" }, extras).map(
+				(e) => e.deviceName,
+			),
+		).toEqual(["Desk", "Side", "Top"]);
+	});
+
+	it("drops extras that name no device at all", () => {
+		expect(dedupeAdditionalWebcams(null, [{ deviceName: "  " }, { deviceName: "Desk" }])).toEqual([
+			{ deviceName: "Desk" },
+		]);
+	});
+
+	it("skips malformed entries from IPC", () => {
+		const junk = [
+			null,
+			{ deviceName: 3 },
+			{ deviceId: 4, deviceName: "X" },
+			{ deviceName: "Desk" },
+		];
+		expect(dedupeAdditionalWebcams(null, junk as unknown as Array<{ deviceName: string }>)).toEqual(
+			[{ deviceName: "Desk" }],
+		);
+	});
+
+	it("drops an empty additional camera file and names it", () => {
+		const r = collectStoppedWebcams({
+			camera1Enabled: true,
+			requested: [
+				{ path: "w.mp4", label: "Front" },
+				{ path: "w-2.mp4", label: "Desk" },
+				{ path: "w-3.mp4", label: "Side" },
+			],
+			sizes: new Map([
+				["w.mp4", 100],
+				["w-2.mp4", 0],
+				["w-3.mp4", 50],
+			]),
+		});
+		expect(r).toEqual({
+			camera1: "w.mp4",
+			additional: [{ path: "w-3.mp4", label: "Side" }],
+			dropped: ["Desk"],
+		});
+	});
+
+	it("keeps camera 1 and reports a camera whose file never appeared as not recorded", () => {
+		const r = collectStoppedWebcams({
+			camera1Enabled: true,
+			requested: [
+				{ path: "w.mp4", label: "Front" },
+				{ path: "w-2.mp4", label: "Desk" },
+			],
+			sizes: new Map([["w.mp4", 100]]),
+		});
+		expect(r).toEqual({ camera1: "w.mp4", additional: [], dropped: ["Desk"] });
+	});
+
+	it("keeps extras when camera 1 is lost, leaving camera 1 out of dropped", () => {
+		const r = collectStoppedWebcams({
+			camera1Enabled: true,
+			requested: [
+				{ path: "w.mp4", label: "Front" },
+				{ path: "w-2.mp4", label: "Desk" },
+			],
+			sizes: new Map([
+				["w.mp4", 0],
+				["w-2.mp4", 10],
+			]),
+		});
+		expect(r).toEqual({ additional: [{ path: "w-2.mp4", label: "Desk" }], dropped: [] });
+	});
+
+	it("maps unavailable helper indices to the labels of the extras", () => {
+		const requested = [
+			{ path: "w.mp4", label: "Front" },
+			{ path: "w-2.mp4", label: "Desk" },
+			{ path: "w-3.mp4", label: "Side" },
+		];
+		expect(labelsOfUnavailableAdditionalWebcams(requested, [0, 2, 2, 9])).toEqual(["Side"]);
+	});
+
+	it("builds a start config with the legacy fields and a list of every camera", () => {
+		const config = buildHelperWebcamConfig({
+			camera1: {
+				enabled: true,
+				deviceId: "id-1",
+				deviceName: "Front",
+				width: 1280,
+				height: 720,
+				fps: 30,
+			},
+			camera1Clsid: "{c1}",
+			camera1Path: "C:\\r\\rec-7-webcam.mp4",
+			extras: [
+				{ deviceId: "id-2", deviceName: "Desk", clsid: null, path: "C:\\r\\rec-7-webcam-2.mp4" },
+			],
+		});
+		const parsed = JSON.parse(JSON.stringify(config));
+		expect(parsed).toMatchObject({
+			webcamEnabled: true,
+			webcamDeviceId: "id-1",
+			webcamDeviceName: "Front",
+			webcamDirectShowClsid: "{c1}",
+			webcamWidth: 1280,
+			webcamHeight: 720,
+			webcamFps: 30,
+		});
+		expect(parsed.webcams).toEqual([
+			{
+				camDeviceId: "id-1",
+				camDeviceName: "Front",
+				camClsid: "{c1}",
+				camWidth: 1280,
+				camHeight: 720,
+				camFps: 30,
+				camPath: "C:\\r\\rec-7-webcam.mp4",
+			},
+			{
+				camDeviceId: "id-2",
+				camDeviceName: "Desk",
+				camClsid: null,
+				camWidth: 1280,
+				camHeight: 720,
+				camFps: 30,
+				camPath: "C:\\r\\rec-7-webcam-2.mp4",
+			},
+		]);
+	});
+
+	it("sends no camera list while camera 1 is off", () => {
+		const config = buildHelperWebcamConfig({
+			camera1: { enabled: false, width: 1280, height: 720, fps: 30 },
+			camera1Clsid: null,
+			camera1Path: "C:\\r\\rec-7-webcam.mp4",
+			extras: [{ deviceName: "Desk", clsid: null, path: "C:\\r\\rec-7-webcam-2.mp4" }],
+		});
+		expect(config.webcamEnabled).toBe(false);
+		expect(config.webcams).toEqual([]);
+	});
+});
diff --git a/electron/recording/nativeWindowsWebcams.ts b/electron/recording/nativeWindowsWebcams.ts
new file mode 100644
index 000000000..42e87365a
--- /dev/null
+++ b/electron/recording/nativeWindowsWebcams.ts
@@ -0,0 +1,202 @@
+/**
+ * Pure helpers for recording several cameras with the native Windows helper.
+ *
+ * Camera 1 stays exactly what it always was: the helper's legacy `webcam*`
+ * fields, the file `<prefix><id>-webcam.mp4` and the session's
+ * `webcamVideoPath`. Cameras 2-4 ride along in the helper's `webcams` list and
+ * in the session's `additionalWebcams`. Kept out of `electron/ipc/handlers.ts`
+ * because that module cannot be loaded from a test.
+ */
+import path from "node:path";
+import { type AdditionalWebcam, MAX_ADDITIONAL_WEBCAMS } from "../../src/lib/recordingSession";
+
+/** `-webcam` (camera 1) or `-webcam-<2..9>` at the end of a file's base name. */
+const WEBCAM_SUFFIX = /-webcam(?:-[2-9])?$/;
+
+/** Camera 1 → `<prefix><id>-webcam.mp4`, camera n ≥ 2 → `<prefix><id>-webcam-<n>.mp4`. */
+export function webcamOutputPath(
+	dir: string,
+	prefix: string,
+	recordingId: number,
+	cameraNumber: number,
+): string {
+	const suffix = cameraNumber <= 1 ? "-webcam" : `-webcam-${cameraNumber}`;
+	return path.join(dir, `${prefix}${recordingId}${suffix}.mp4`);
+}
+
+/** Whether a file name is one of a recording's camera files (any extension). */
+export function isWebcamSidecarFile(fileName: string): boolean {
+	return WEBCAM_SUFFIX.test(path.parse(fileName).name);
+}
+
+/** The recording's base name for a camera file's base name; other names pass through. */
+export function stripWebcamSuffix(baseName: string): string {
+	return baseName.replace(WEBCAM_SUFFIX, "");
+}
+
+/** One camera in the helper config's `webcams` list (keys are the helper's). */
+export interface HelperWebcamEntry {
+	camDeviceId: string | null;
+	camDeviceName: string;
+	camClsid: string | null;
+	camWidth: number;
+	camHeight: number;
+	camFps: number;
+	camPath: string;
+}
+
+type DeviceRef = { deviceId?: string; deviceName?: string };
+
+/** Same device: by id when both sides carry one, otherwise by name. */
+function isSameDevice(a: DeviceRef, b: DeviceRef) {
+	if (a.deviceId && b.deviceId) {
+		return a.deviceId === b.deviceId;
+	}
+	const name = a.deviceName?.trim();
+	return Boolean(name) && name === b.deviceName?.trim();
+}
+
+/**
+ * The additional cameras worth asking the helper for: no malformed entry, no
+ * entry that names no device, none equal to camera 1, no duplicates, and at most
+ * {@link MAX_ADDITIONAL_WEBCAMS}.
+ */
+export function dedupeAdditionalWebcams<T extends { deviceId?: string; deviceName: string }>(
+	camera1: DeviceRef | null,
+	extras: T[],
+): T[] {
+	const kept: T[] = [];
+	for (const extra of extras) {
+		if (kept.length >= MAX_ADDITIONAL_WEBCAMS) {
+			break;
+		}
+		// The list crosses IPC, so a malformed entry is skipped rather than trusted.
+		if (
+			!extra ||
+			typeof extra.deviceName !== "string" ||
+			(extra.deviceId !== undefined && typeof extra.deviceId !== "string")
+		) {
+			continue;
+		}
+		if (!extra.deviceId && !extra.deviceName.trim()) {
+			continue;
+		}
+		if (camera1 && isSameDevice(camera1, extra)) {
+			continue;
+		}
+		if (kept.some((other) => isSameDevice(other, extra))) {
+			continue;
+		}
+		kept.push(extra);
+	}
+	return kept;
+}
+
+/**
+ * The camera part of the helper config: the unchanged legacy `webcam*` fields
+ * for camera 1 plus the `webcams` list (camera 1 first, then the extras).
+ *
+ * Extras are recorded only while camera 1 is on (the HUD's camera toggle
+ * governs every camera), so with camera 1 off the list is empty. Every extra
+ * uses camera 1's requested size and rate: the quality setting is one for all.
+ */
+export function buildHelperWebcamConfig(input: {
+	camera1: {
+		enabled: boolean;
+		deviceId?: string;
+		deviceName?: string;
+		width: number;
+		height: number;
+		fps: number;
+	};
+	camera1Clsid: string | null;
+	camera1Path: string;
+	extras: Array<{ deviceId?: string; deviceName: string; clsid: string | null; path: string }>;
+}) {
+	const { camera1 } = input;
+	const entry = (
+		device: { deviceId?: string; deviceName?: string },
+		clsid: string | null,
+		camPath: string,
+	): HelperWebcamEntry => ({
+		camDeviceId: device.deviceId ?? null,
+		camDeviceName: device.deviceName ?? "",
+		camClsid: clsid,
+		camWidth: camera1.width,
+		camHeight: camera1.height,
+		camFps: camera1.fps,
+		camPath,
+	});
+	const webcams: HelperWebcamEntry[] = camera1.enabled
+		? [
+				entry(camera1, input.camera1Clsid, input.camera1Path),
+				...input.extras.map((extra) => entry(extra, extra.clsid, extra.path)),
+			]
+		: [];
+	return {
+		webcamEnabled: camera1.enabled,
+		webcamDeviceId: camera1.deviceId ?? null,
+		webcamDeviceName: camera1.deviceName ?? null,
+		webcamDirectShowClsid: input.camera1Clsid,
+		webcamWidth: camera1.width,
+		webcamHeight: camera1.height,
+		webcamFps: camera1.fps,
+		webcams,
+	};
+}
+
+/**
+ * Labels of the additional cameras the helper reported unavailable. The
+ * helper's index is the position in the `webcams` list, which is the position
+ * in `requested` (camera 1 first). Index 0 is camera 1 and is left out: the
+ * caller reports camera 1 through its own `webcamUnavailable` flag. The labels
+ * come from our own list because the helper's `deviceName` can be empty.
+ */
+export function labelsOfUnavailableAdditionalWebcams(
+	requested: Array<{ label: string }>,
+	indices: number[],
+): string[] {
+	const labels: string[] = [];
+	for (const index of new Set(indices)) {
+		const camera = index > 0 ? requested[index] : undefined;
+		if (camera) {
+			labels.push(camera.label);
+		}
+	}
+	return labels;
+}
+
+/**
+ * Which requested cameras made it into the take.
+ *
+ * A camera is kept when its file exists with size > 0. The helper's own list
+ * at stop is deliberately not consulted: it names the cameras still recording
+ * at that moment, so a camera that died mid-take with a playable partial file
+ * would be missing from it, and an old helper names only camera 1. A file that
+ * never appeared is simply absent from `sizes`.
+ *
+ * `camera1Enabled` says whether `requested[0]` is camera 1. Camera 1 comes back
+ * as `camera1` (undefined when lost) and is never in `dropped`, which names
+ * only the additional cameras not kept — the caller reports camera 1 through
+ * its own `webcamDropped` flag.
+ */
+export function collectStoppedWebcams(input: {
+	camera1Enabled: boolean;
+	requested: Array<{ path: string; label: string }>;
+	sizes: Map<string, number>;
+}): { camera1?: string; additional: AdditionalWebcam[]; dropped: string[] } {
+	const isKept = (filePath: string) => (input.sizes.get(filePath) ?? 0) > 0;
+	const [first, ...rest] = input.requested;
+	const camera1 = input.camera1Enabled && first && isKept(first.path) ? first.path : undefined;
+	const extras = input.camera1Enabled ? rest : input.requested;
+	const additional: AdditionalWebcam[] = [];
+	const dropped: string[] = [];
+	for (const camera of extras) {
+		if (isKept(camera.path)) {
+			additional.push({ path: camera.path, label: camera.label });
+		} else {
+			dropped.push(camera.label);
+		}
+	}
+	return { ...(camera1 ? { camera1 } : {}), additional, dropped };
+}
diff --git a/src/lib/nativeWindowsRecording.ts b/src/lib/nativeWindowsRecording.ts
index 5d5d92b31..c014cf243 100644
--- a/src/lib/nativeWindowsRecording.ts
+++ b/src/lib/nativeWindowsRecording.ts
@@ -34,6 +34,11 @@ export type NativeWindowsRecordingRequest = {
 		height: number;
 		fps: number;
 	};
+	/**
+	 * Cameras 2-4, recorded at camera 1's size and rate. Only sent while camera 1
+	 * is enabled; the main process drops duplicates of camera 1 and caps the list.
+	 */
+	additionalWebcams?: Array<{ deviceId?: string; deviceName: string }>;
 	cursor: {
 		mode: import("./recordingSession").CursorCaptureMode;
 	};
@@ -60,6 +65,11 @@ export type NativeWindowsRecordingStartResult = {
 	 * but the user has to be told, or they discover it in the editor.
 	 */
 	webcamUnavailable?: boolean;
+	/**
+	 * Device names of additional cameras (2-4) the helper could not open; this
+	 * take records without them. Camera 1 is reported by `webcamUnavailable`.
+	 */
+	unavailableWebcams?: string[];
 	/**
 	 * A microphone was asked for but could not be named, so the helper captured
 	 * whatever Windows calls the default input. The take is fine; the voice on it

From 9665e7be0815f8d5bb7ef2ddf278ee03aef88ebd Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 12:19:19 +0200
Subject: [PATCH 07/22] fix(wgc): never open the same camera twice in one take

Two webcams of the same model report the same name, and the browser id never matches a device path, so every such camera selected the first device and the second open failed as busy. The take now owns a claim set: each camera that opens adds its device (MF symbolic link or DirectShow DevicePath, normalized so both paths agree), and later cameras pick the best unclaimed match. The selection rule lives in device_selection.{h,cpp} with its own unit test.
---
 electron/native/wgc-capture/CMakeLists.txt    |  16 ++
 .../wgc-capture/src/device_selection.cpp      | 158 +++++++++++++
 .../native/wgc-capture/src/device_selection.h |  89 ++++++++
 .../wgc-capture/src/device_selection_test.cpp | 100 +++++++++
 .../wgc-capture/src/dshow_webcam_capture.cpp  |  85 ++++++-
 .../wgc-capture/src/dshow_webcam_capture.h    |  11 +-
 electron/native/wgc-capture/src/main.cpp      |   7 +-
 .../native/wgc-capture/src/webcam_capture.cpp | 210 +++++-------------
 .../native/wgc-capture/src/webcam_capture.h   |  20 +-
 scripts/build-windows-wgc-helper.mjs          |   8 +
 10 files changed, 539 insertions(+), 165 deletions(-)
 create mode 100644 electron/native/wgc-capture/src/device_selection.cpp
 create mode 100644 electron/native/wgc-capture/src/device_selection.h
 create mode 100644 electron/native/wgc-capture/src/device_selection_test.cpp

diff --git a/electron/native/wgc-capture/CMakeLists.txt b/electron/native/wgc-capture/CMakeLists.txt
index 84aa89853..870f4003a 100644
--- a/electron/native/wgc-capture/CMakeLists.txt
+++ b/electron/native/wgc-capture/CMakeLists.txt
@@ -39,6 +39,8 @@ add_executable(wgc-capture
   src/audio_sample_utils.cpp
   src/audio_sample_utils.h
   src/desktop_icon_cover.cpp
+  src/device_selection.cpp
+  src/device_selection.h
   src/desktop_icon_cover.h
   src/dpi_awareness.h
   src/realtime_scheduling.h
@@ -218,3 +220,17 @@ target_compile_definitions(webcam_config_test PRIVATE
 )
 
 target_compile_options(webcam_config_test PRIVATE /EHsc /W4 /utf-8)
+
+add_executable(device_selection_test
+  src/device_selection.cpp
+  src/device_selection.h
+  src/device_selection_test.cpp
+)
+
+target_compile_definitions(device_selection_test PRIVATE
+  NOMINMAX
+  WIN32_LEAN_AND_MEAN
+  _WIN32_WINNT=0x0A00
+)
+
+target_compile_options(device_selection_test PRIVATE /EHsc /W4 /utf-8)
diff --git a/electron/native/wgc-capture/src/device_selection.cpp b/electron/native/wgc-capture/src/device_selection.cpp
new file mode 100644
index 000000000..3211cbd1d
--- /dev/null
+++ b/electron/native/wgc-capture/src/device_selection.cpp
@@ -0,0 +1,158 @@
+#include "device_selection.h"
+
+#include <algorithm>
+#include <cwctype>
+
+namespace {
+
+/**
+ * Does one of these appear inside the other as WHOLE WORDS?
+ *
+ * Plain containment answered for devices that merely share a spelling: a
+ * requested "Logi" is inside "Logitech", and "Micro" inside "Microphone",
+ * neither of them as a word. Matching on that resolved a camera nobody asked
+ * for -- and resolving one is exactly what stops the request reaching the
+ * DirectShow fallback, where the cameras Media Foundation cannot enumerate live.
+ *
+ * Both sides arrive normalized, so a boundary is the start of the string, its
+ * end, or a space.
+ */
+bool containsAsWords(const std::wstring& haystack, const std::wstring& needle) {
+    if (haystack.empty() || needle.empty()) {
+        return false;
+    }
+    size_t pos = haystack.find(needle);
+    while (pos != std::wstring::npos) {
+        const bool startsOnBoundary = pos == 0 || haystack[pos - 1] == L' ';
+        const size_t after = pos + needle.size();
+        const bool endsOnBoundary = after == haystack.size() || haystack[after] == L' ';
+        if (startsOnBoundary && endsOnBoundary) {
+            return true;
+        }
+        pos = haystack.find(needle, pos + 1);
+    }
+    return false;
+}
+
+bool containsInsensitive(const std::wstring& haystack, const std::wstring& needle) {
+    return containsAsWords(haystack, needle) || containsAsWords(needle, haystack);
+}
+
+std::wstring normalizeDeviceName(const std::wstring& value) {
+    std::wstring normalized;
+    normalized.reserve(value.size());
+    bool lastWasSpace = true;
+    for (const wchar_t ch : value) {
+        if (std::iswalnum(ch)) {
+            normalized.push_back(static_cast<wchar_t>(std::towlower(ch)));
+            lastWasSpace = false;
+            continue;
+        }
+        if (!lastWasSpace) {
+            normalized.push_back(L' ');
+            lastWasSpace = true;
+        }
+    }
+    while (!normalized.empty() && normalized.back() == L' ') {
+        normalized.pop_back();
+    }
+    return normalized;
+}
+
+std::wstring toLower(const std::wstring& value) {
+    std::wstring lowered;
+    lowered.reserve(value.size());
+    for (const wchar_t ch : value) {
+        lowered.push_back(static_cast<wchar_t>(std::towlower(ch)));
+    }
+    return lowered;
+}
+
+} // namespace
+
+bool DeviceClaims::contains(const std::wstring& identity) const {
+    const std::wstring normalized = normalizeDeviceIdentity(identity);
+    return !normalized.empty() &&
+           std::find(identities_.begin(), identities_.end(), normalized) != identities_.end();
+}
+
+void DeviceClaims::add(const std::wstring& identity) {
+    const std::wstring normalized = normalizeDeviceIdentity(identity);
+    if (!normalized.empty() &&
+        std::find(identities_.begin(), identities_.end(), normalized) == identities_.end()) {
+        identities_.push_back(normalized);
+    }
+}
+
+std::wstring normalizeDeviceIdentity(const std::wstring& identity) {
+    const std::wstring lowered = toLower(identity);
+    const size_t interfaceClass = lowered.rfind(L"#{");
+    if (interfaceClass == std::wstring::npos || interfaceClass == 0) {
+        return lowered;
+    }
+    const size_t classEnd = lowered.find(L'}', interfaceClass);
+    if (classEnd == std::wstring::npos) {
+        return lowered;
+    }
+    return lowered.substr(0, interfaceClass) + lowered.substr(classEnd + 1);
+}
+
+int deviceMatchScore(
+    const std::wstring& candidateName,
+    const std::wstring& candidateLink,
+    const std::wstring& requestedName,
+    const std::wstring& requestedId) {
+    int score = 0;
+    const auto normalizedName = normalizeDeviceName(candidateName);
+    const auto normalizedLink = normalizeDeviceName(candidateLink);
+    const auto normalizedRequestedName = normalizeDeviceName(requestedName);
+    const auto normalizedRequestedId = normalizeDeviceName(requestedId);
+
+    if (!normalizedRequestedName.empty()) {
+        if (normalizedName == normalizedRequestedName) {
+            score = std::max(score, 1000);
+        }
+        if (containsInsensitive(normalizedName, normalizedRequestedName)) {
+            score = std::max(score, 900);
+        }
+        if (containsInsensitive(normalizedLink, normalizedRequestedName)) {
+            score = std::max(score, 800);
+        }
+    }
+
+    if (!normalizedRequestedId.empty()) {
+        if (containsInsensitive(normalizedLink, normalizedRequestedId)) {
+            score = std::max(score, 700);
+        }
+        if (containsInsensitive(normalizedName, normalizedRequestedId)) {
+            score = std::max(score, 600);
+        }
+    }
+
+    return score;
+}
+
+int selectUnclaimedDevice(
+    const std::vector<DeviceCandidate>& candidates,
+    const std::wstring& requestedName,
+    const std::wstring& requestedId,
+    const DeviceClaims& claims) {
+    const bool requested = !requestedName.empty() || !requestedId.empty();
+    int selected = -1;
+    int bestScore = 0;
+    for (size_t index = 0; index < candidates.size(); ++index) {
+        if (claims.contains(candidates[index].identity)) {
+            continue;
+        }
+        const int score =
+            deviceMatchScore(candidates[index].name, candidates[index].identity, requestedName, requestedId);
+        if (requested && score <= 0) {
+            continue;
+        }
+        if (selected < 0 || score > bestScore) {
+            selected = static_cast<int>(index);
+            bestScore = score;
+        }
+    }
+    return selected;
+}
diff --git a/electron/native/wgc-capture/src/device_selection.h b/electron/native/wgc-capture/src/device_selection.h
new file mode 100644
index 000000000..bcdc2ad8f
--- /dev/null
+++ b/electron/native/wgc-capture/src/device_selection.h
@@ -0,0 +1,89 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+/**
+ * Which camera devices are already recording in this take.
+ *
+ * Two webcams of the same model report the same friendly name, and the id the
+ * browser hands us is a salted hash that never matches a device path, so name
+ * matching alone sends every such camera to the FIRST physical device. The
+ * second open then fails as busy and that camera is lost. Each camera that
+ * opens adds its device identity here, and later cameras of the take skip it.
+ *
+ * Identities are compared normalized (see `normalizeDeviceIdentity`), so a
+ * device opened through Media Foundation is recognized when it turns up again
+ * on the DirectShow fallback.
+ */
+class DeviceClaims {
+public:
+    bool contains(const std::wstring& identity) const;
+    /** Ignores an empty identity: a device we cannot name cannot be claimed. */
+    void add(const std::wstring& identity);
+
+private:
+    std::vector<std::wstring> identities_;
+};
+
+/** One device a capture backend enumerated. */
+struct DeviceCandidate {
+    std::wstring name;
+    /** The Media Foundation symbolic link or the DirectShow DevicePath. */
+    std::wstring identity;
+};
+
+/**
+ * The part of a device interface path that names the physical device.
+ *
+ * Media Foundation's symbolic link and DirectShow's DevicePath are the same
+ * `\\?\usb#vid_…#<instance>#{interface class}\<reference>` string, except that
+ * each registers the camera under its own interface class GUID (measured on a
+ * Snapdragon front camera: KSCATEGORY_VIDEO_CAMERA against KSCATEGORY_VIDEO).
+ * Dropping the `#{…}` class and lowercasing leaves the device instance plus the
+ * reference string, which both share. The reference string is kept because it
+ * tells apart two cameras of one device (a colour and an IR sensor). A value
+ * without that shape (a moniker display name) is only lowercased.
+ */
+std::wstring normalizeDeviceIdentity(const std::wstring& identity);
+
+/**
+ * How well a candidate answers a requested name, or 0 for "not this one".
+ *
+ * Only decisive matches count: the names being equal once normalized, or one
+ * containing the other -- which is the ordinary case, since Chromium appends USB
+ * ids to what the driver reports.
+ *
+ * A further tier used to score shared WORDS, to bridge names differing more than
+ * that. It bridged names that were not the same device. "Logi Capture" and
+ * "Logitech StreamCam" share no word, yet "logi" sits inside "logitech" and that
+ * scored high enough to win -- so asking for a camera Media Foundation cannot
+ * enumerate opened a DIFFERENT camera, instead of returning nothing and letting
+ * the DirectShow fallback find the real one (getopenscreen/openscreen#405).
+ *
+ * Returning 0 is what makes that fallback reachable, so it is a real answer
+ * rather than a weak match. Keep this in step with
+ * `electron/recording/deviceNameMatching.ts`, which states the same rules for
+ * the Electron side and carries their unit tests.
+ */
+int deviceMatchScore(
+    const std::wstring& candidateName,
+    const std::wstring& candidateLink,
+    const std::wstring& requestedName,
+    const std::wstring& requestedId);
+
+/**
+ * The candidate a camera should open, or -1 for none.
+ *
+ * Claimed candidates are skipped; among the rest the best `deviceMatchScore`
+ * wins, the earlier one on a tie. With nothing requested that is the first
+ * unclaimed device. With a name or id requested, a candidate scoring 0 is never
+ * picked -- the same rule as before claims existed, and what lets the caller
+ * fall back to DirectShow. With an empty claim set this is exactly the old
+ * selection.
+ */
+int selectUnclaimedDevice(
+    const std::vector<DeviceCandidate>& candidates,
+    const std::wstring& requestedName,
+    const std::wstring& requestedId,
+    const DeviceClaims& claims);
diff --git a/electron/native/wgc-capture/src/device_selection_test.cpp b/electron/native/wgc-capture/src/device_selection_test.cpp
new file mode 100644
index 000000000..aa6329f66
--- /dev/null
+++ b/electron/native/wgc-capture/src/device_selection_test.cpp
@@ -0,0 +1,100 @@
+#include "device_selection.h"
+
+#include <cstdio>
+#include <string>
+#include <vector>
+
+namespace {
+int failures = 0;
+void expect(bool ok, const char* label) {
+    if (!ok) {
+        std::printf("FAIL %s\n", label);
+        ++failures;
+    }
+}
+}  // namespace
+
+int main() {
+    const std::vector<DeviceCandidate> twins = {
+        {L"USB Camera", L"\\\\?\\usb#vid_0c45&pid_6366&mi_00#7&aaa&0&0000#{e5323777-f976-4f5b-9b55-b94699c46e44}\\global"},
+        {L"USB Camera", L"\\\\?\\usb#vid_0c45&pid_6366&mi_00#7&bbb&0&0000#{e5323777-f976-4f5b-9b55-b94699c46e44}\\global"},
+    };
+
+    DeviceClaims none;
+    expect(selectUnclaimedDevice(twins, L"USB Camera", L"", none) == 0,
+           "same names, nothing claimed: first");
+
+    DeviceClaims first;
+    first.add(twins[0].identity);
+    expect(selectUnclaimedDevice(twins, L"USB Camera", L"", first) == 1,
+           "same names, first claimed: second");
+
+    DeviceClaims both;
+    both.add(twins[0].identity);
+    both.add(twins[1].identity);
+    expect(selectUnclaimedDevice(twins, L"USB Camera", L"", both) == -1,
+           "same names, both claimed: none");
+    expect(selectUnclaimedDevice(twins, L"", L"", both) == -1,
+           "nothing requested, both claimed: none");
+
+    DeviceClaims upper;
+    upper.add(L"\\\\?\\USB#VID_0C45&PID_6366&MI_00#7&AAA&0&0000#{E5323777-F976-4F5B-9B55-B94699C46E44}\\GLOBAL");
+    expect(selectUnclaimedDevice(twins, L"USB Camera", L"", upper) == 1,
+           "claim comparison is case-insensitive");
+
+    // DirectShow registers the same device under its own interface class GUID.
+    DeviceClaims viaDirectShow;
+    viaDirectShow.add(
+        L"\\\\?\\usb#vid_0c45&pid_6366&mi_00#7&aaa&0&0000#{65e8773d-8f56-11d0-a3b9-00a0c9223196}\\global");
+    expect(viaDirectShow.contains(twins[0].identity), "MF link and DirectShow path are one device");
+    expect(!viaDirectShow.contains(twins[1].identity), "the twin is a different device");
+
+    const std::vector<DeviceCandidate> mixed = {
+        {L"Studio Cam", L"\\\\?\\usb#vid_1#a#{e5323777-f976-4f5b-9b55-b94699c46e44}\\global"},
+        {L"Studio Cam Pro", L"\\\\?\\usb#vid_2#b#{e5323777-f976-4f5b-9b55-b94699c46e44}\\global"},
+        {L"Other Camera", L"\\\\?\\usb#vid_3#c#{e5323777-f976-4f5b-9b55-b94699c46e44}\\global"},
+    };
+    DeviceClaims exact;
+    exact.add(mixed[0].identity);
+    expect(selectUnclaimedDevice(mixed, L"Studio Cam", L"", none) == 0, "exact name wins unclaimed");
+    expect(selectUnclaimedDevice(mixed, L"Studio Cam", L"", exact) == 1,
+           "claimed exact match loses to a weaker unclaimed match");
+    DeviceClaims bothStudio = exact;
+    bothStudio.add(mixed[1].identity);
+    expect(selectUnclaimedDevice(mixed, L"Studio Cam", L"", bothStudio) == -1,
+           "a non-matching device is never picked for a request");
+    expect(selectUnclaimedDevice(mixed, L"Nonexistent", L"", none) == -1,
+           "no match for a request: none");
+    expect(selectUnclaimedDevice(mixed, L"", L"", none) == 0, "nothing requested: first device");
+    expect(selectUnclaimedDevice(mixed, L"", L"", exact) == 1,
+           "nothing requested: first unclaimed device");
+    expect(selectUnclaimedDevice({}, L"", L"", none) == -1, "no candidates: none");
+
+    // Measured on an ARM64 dev machine: the front camera as Media Foundation and
+    // as DirectShow list it.
+    DeviceClaims frontCamera;
+    frontCamera.add(
+        L"\\\\?\\display#qcom_avstream_8380#3&2dd9d5f4&0&uid32768#{e5323777-f976-4f5b-9b55-b94699c46e44}"
+        L"\\{4faeafd4-041b-4e46-85fd-400473891182}");
+    expect(frontCamera.contains(
+               L"\\\\?\\DISPLAY#QCOM_AVSTREAM_8380#3&2DD9D5F4&0&UID32768#{65E8773D-8F56-11D0-A3B9-00A0C9223196}"
+               L"\\{4FAEAFD4-041B-4E46-85FD-400473891182}"),
+           "measured MF link and DirectShow path are one device");
+    expect(!frontCamera.contains(
+               L"\\\\?\\display#qcom_avstream_8380#3&2dd9d5f4&0&uid32768#{e5323777-f976-4f5b-9b55-b94699c46e44}"
+               L"\\{00000000-0000-0000-0000-000000000001}"),
+           "another reference string on the same device is another camera");
+
+    DeviceClaims empty;
+    empty.add(L"");
+    expect(!empty.contains(L""), "an empty identity is never claimed");
+    expect(normalizeDeviceIdentity(L"@device:sw:{ABC}") == L"@device:sw:{abc}",
+           "identity without an interface class is only lowercased");
+
+    if (failures == 0) {
+        std::printf("device_selection_test: all assertions passed\n");
+        return 0;
+    }
+    std::printf("device_selection_test: %d failure(s)\n", failures);
+    return 1;
+}
diff --git a/electron/native/wgc-capture/src/dshow_webcam_capture.cpp b/electron/native/wgc-capture/src/dshow_webcam_capture.cpp
index 915e3dc4a..c7773505a 100644
--- a/electron/native/wgc-capture/src/dshow_webcam_capture.cpp
+++ b/electron/native/wgc-capture/src/dshow_webcam_capture.cpp
@@ -109,6 +109,63 @@ std::array<BYTE, 3> yuvToBgr(int y, int u, int v) {
     return {clampToByte(blue), clampToByte(green), clampToByte(red)};
 }
 
+std::wstring readPropertyString(IPropertyBag* properties, const wchar_t* name) {
+    VARIANT value;
+    VariantInit(&value);
+    std::wstring result;
+    if (SUCCEEDED(properties->Read(name, &value, nullptr)) && value.vt == VT_BSTR && value.bstrVal) {
+        result = value.bstrVal;
+    }
+    VariantClear(&value);
+    return result;
+}
+
+/**
+ * The video input devices DirectShow lists for the filter `clsid`.
+ *
+ * The fallback opens its filter by CLSID, which says nothing about WHICH
+ * device that is. The moniker does: its DevicePath is the same interface path
+ * Media Foundation reports as the symbolic link, so a device already opened
+ * there is recognized here. A moniker without a DevicePath (a plain software
+ * filter) is named by its display name instead.
+ */
+std::vector<DeviceCandidate> enumerateDevicesForClsid(const CLSID& clsid) {
+    std::vector<DeviceCandidate> candidates;
+    Microsoft::WRL::ComPtr<ICreateDevEnum> deviceEnumerator;
+    if (FAILED(CoCreateInstance(CLSID_SystemDeviceEnum, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&deviceEnumerator)))) {
+        return candidates;
+    }
+    Microsoft::WRL::ComPtr<IEnumMoniker> monikers;
+    // S_FALSE: the category is empty.
+    if (deviceEnumerator->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &monikers, 0) != S_OK || !monikers) {
+        return candidates;
+    }
+    Microsoft::WRL::ComPtr<IMoniker> moniker;
+    while (monikers->Next(1, &moniker, nullptr) == S_OK) {
+        Microsoft::WRL::ComPtr<IPropertyBag> properties;
+        if (SUCCEEDED(moniker->BindToStorage(nullptr, nullptr, IID_PPV_ARGS(&properties)))) {
+            CLSID monikerClsid{};
+            const std::wstring clsidText = readPropertyString(properties.Get(), L"CLSID");
+            if (!clsidText.empty() && SUCCEEDED(CLSIDFromString(clsidText.c_str(), &monikerClsid)) &&
+                IsEqualCLSID(monikerClsid, clsid)) {
+                DeviceCandidate candidate{
+                    readPropertyString(properties.Get(), L"FriendlyName"),
+                    readPropertyString(properties.Get(), L"DevicePath")};
+                if (candidate.identity.empty()) {
+                    LPOLESTR displayName = nullptr;
+                    if (SUCCEEDED(moniker->GetDisplayName(nullptr, nullptr, &displayName)) && displayName) {
+                        candidate.identity = displayName;
+                        CoTaskMemFree(displayName);
+                    }
+                }
+                candidates.push_back(std::move(candidate));
+            }
+        }
+        moniker.Reset();
+    }
+    return candidates;
+}
+
 } // namespace
 
 struct DirectShowWebcamCapture::Impl {
@@ -294,7 +351,8 @@ bool DirectShowWebcamCapture::initialize(
     const std::wstring& directShowClsid,
     int requestedWidth,
     int requestedHeight,
-    int requestedFps) {
+    int requestedFps,
+    const DeviceClaims& claims) {
     (void)deviceId;
     stop();
     delete impl_;
@@ -321,6 +379,27 @@ bool DirectShowWebcamCapture::initialize(
     }
     selectedDeviceName_ = deviceName.empty() ? directShowClsid : deviceName;
 
+    // Every device this filter stands for has already been matched by name in
+    // Electron, so the only thing left to choose on is which one is free. With
+    // no moniker naming the filter, the CLSID itself is the identity.
+    const std::vector<DeviceCandidate> candidates = enumerateDevicesForClsid(selectedClsid);
+    if (candidates.empty()) {
+        deviceIdentity_ = directShowClsid;
+        if (claims.contains(deviceIdentity_)) {
+            std::cerr << "ERROR: DirectShow webcam filter is already recording in this take" << std::endl;
+            return false;
+        }
+    } else {
+        const int selectedIndex = selectUnclaimedDevice(candidates, L"", L"", claims);
+        if (selectedIndex < 0) {
+            std::cerr << "ERROR: Every DirectShow webcam for this filter is already recording in this take"
+                      << std::endl;
+            return false;
+        }
+        deviceIdentity_ = candidates[selectedIndex].identity;
+    }
+    std::wcerr << L"INFO: DirectShow webcam device " << deviceIdentity_ << std::endl;
+
     // The camera's own format first, a forced RGB32 conversion only if we cannot
     // read it.
     //
@@ -594,6 +673,10 @@ int DirectShowWebcamCapture::fps() const {
     return fps_;
 }
 
+const std::wstring& DirectShowWebcamCapture::deviceIdentity() const {
+    return deviceIdentity_;
+}
+
 const std::wstring& DirectShowWebcamCapture::selectedDeviceName() const {
     return selectedDeviceName_;
 }
diff --git a/electron/native/wgc-capture/src/dshow_webcam_capture.h b/electron/native/wgc-capture/src/dshow_webcam_capture.h
index be4f759a5..2c4393288 100644
--- a/electron/native/wgc-capture/src/dshow_webcam_capture.h
+++ b/electron/native/wgc-capture/src/dshow_webcam_capture.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "device_selection.h"
+
 #include <Windows.h>
 
 #include <atomic>
@@ -57,7 +59,8 @@ class DirectShowWebcamCapture {
         const std::wstring& directShowClsid,
         int requestedWidth,
         int requestedHeight,
-        int requestedFps);
+        int requestedFps,
+        const DeviceClaims& claims);
     bool start();
     void stop();
     bool copyLatestFrame(WebcamFrameSnapshot& destination, uint64_t lastSeenSequence);
@@ -66,6 +69,11 @@ class DirectShowWebcamCapture {
     int height() const;
     int fps() const;
     const std::wstring& selectedDeviceName() const;
+    /**
+     * The opened device's DevicePath (the moniker's display name when it has
+     * none, the filter CLSID when no moniker names it), for the take's claims.
+     */
+    const std::wstring& deviceIdentity() const;
     void storeFrame(const BYTE* buffer, long length);
 
 private:
@@ -123,4 +131,5 @@ class DirectShowWebcamCapture {
     bool sourceTopDown_ = false;
     PixelFormat pixelFormat_ = PixelFormat::Bgra;
     std::wstring selectedDeviceName_;
+    std::wstring deviceIdentity_;
 };
diff --git a/electron/native/wgc-capture/src/main.cpp b/electron/native/wgc-capture/src/main.cpp
index 20e14382c..e7a18082e 100644
--- a/electron/native/wgc-capture/src/main.cpp
+++ b/electron/native/wgc-capture/src/main.cpp
@@ -713,6 +713,10 @@ int wmain(int argc, wchar_t* argv[]) {
     }
 
     std::vector<std::unique_ptr<WebcamStream>> webcams;  // unique_ptr: WebcamCapture/MFEncoder are not movable
+    // The devices this take's cameras opened, so two cameras of the same model
+    // (same name, and a browser id that matches no device) open two devices
+    // rather than the first one twice. A camera dropped later keeps its claim.
+    DeviceClaims deviceClaims;
     for (size_t index = 0; index < webcamConfigs.size(); ++index) {
         auto stream = std::make_unique<WebcamStream>();
         stream->config = webcamConfigs[index];
@@ -729,7 +733,8 @@ int wmain(int argc, wchar_t* argv[]) {
                 stream->config.width,
                 stream->config.height,
                 stream->config.fps > 0 ? stream->config.fps : config.fps,
-                stream->writeSeparate)) {
+                stream->writeSeparate,
+                deviceClaims)) {
             // Non-fatal: a screen+audio recording the user can still use is far
             // better than losing the whole recording because one camera device
             // didn't match. Report it so the renderer can inform the user (and,
diff --git a/electron/native/wgc-capture/src/webcam_capture.cpp b/electron/native/wgc-capture/src/webcam_capture.cpp
index 2a367c67d..b67e1ceac 100644
--- a/electron/native/wgc-capture/src/webcam_capture.cpp
+++ b/electron/native/wgc-capture/src/webcam_capture.cpp
@@ -9,7 +9,6 @@
 
 #include <algorithm>
 #include <chrono>
-#include <cwctype>
 #include <iostream>
 
 namespace {
@@ -36,114 +35,6 @@ std::wstring readAllocatedString(IMFActivate* activate, REFGUID key) {
     return result;
 }
 
-/**
- * Does one of these appear inside the other as WHOLE WORDS?
- *
- * Plain containment answered for devices that merely share a spelling: a
- * requested "Logi" is inside "Logitech", and "Micro" inside "Microphone",
- * neither of them as a word. Matching on that resolved a camera nobody asked
- * for -- and resolving one is exactly what stops the request reaching the
- * DirectShow fallback, where the cameras Media Foundation cannot enumerate live.
- *
- * Both sides arrive normalized, so a boundary is the start of the string, its
- * end, or a space.
- */
-bool containsAsWords(const std::wstring& haystack, const std::wstring& needle) {
-    if (haystack.empty() || needle.empty()) {
-        return false;
-    }
-    size_t pos = haystack.find(needle);
-    while (pos != std::wstring::npos) {
-        const bool startsOnBoundary = pos == 0 || haystack[pos - 1] == L' ';
-        const size_t after = pos + needle.size();
-        const bool endsOnBoundary = after == haystack.size() || haystack[after] == L' ';
-        if (startsOnBoundary && endsOnBoundary) {
-            return true;
-        }
-        pos = haystack.find(needle, pos + 1);
-    }
-    return false;
-}
-
-bool containsInsensitive(const std::wstring& haystack, const std::wstring& needle) {
-    return containsAsWords(haystack, needle) || containsAsWords(needle, haystack);
-}
-
-std::wstring normalizeDeviceName(const std::wstring& value) {
-    std::wstring normalized;
-    normalized.reserve(value.size());
-    bool lastWasSpace = true;
-    for (const wchar_t ch : value) {
-        if (std::iswalnum(ch)) {
-            normalized.push_back(static_cast<wchar_t>(std::towlower(ch)));
-            lastWasSpace = false;
-            continue;
-        }
-        if (!lastWasSpace) {
-            normalized.push_back(L' ');
-            lastWasSpace = true;
-        }
-    }
-    while (!normalized.empty() && normalized.back() == L' ') {
-        normalized.pop_back();
-    }
-    return normalized;
-}
-
-/**
- * How well a candidate answers a requested name, or 0 for "not this one".
- *
- * Only decisive matches count: the names being equal once normalized, or one
- * containing the other -- which is the ordinary case, since Chromium appends USB
- * ids to what the driver reports.
- *
- * A further tier used to score shared WORDS, to bridge names differing more than
- * that. It bridged names that were not the same device. "Logi Capture" and
- * "Logitech StreamCam" share no word, yet "logi" sits inside "logitech" and that
- * scored high enough to win -- so asking for a camera Media Foundation cannot
- * enumerate opened a DIFFERENT camera, instead of returning nothing and letting
- * the DirectShow fallback find the real one (getopenscreen/openscreen#405).
- *
- * Returning 0 is what makes that fallback reachable, so it is a real answer
- * rather than a weak match. Keep this in step with
- * `electron/recording/deviceNameMatching.ts`, which states the same rules for
- * the Electron side and carries their unit tests.
- */
-int deviceMatchScore(
-    const std::wstring& candidateName,
-    const std::wstring& candidateLink,
-    const std::wstring& requestedName,
-    const std::wstring& requestedId) {
-    int score = 0;
-    const auto normalizedName = normalizeDeviceName(candidateName);
-    const auto normalizedLink = normalizeDeviceName(candidateLink);
-    const auto normalizedRequestedName = normalizeDeviceName(requestedName);
-    const auto normalizedRequestedId = normalizeDeviceName(requestedId);
-
-    if (!normalizedRequestedName.empty()) {
-        if (normalizedName == normalizedRequestedName) {
-            score = std::max(score, 1000);
-        }
-        if (containsInsensitive(normalizedName, normalizedRequestedName)) {
-            score = std::max(score, 900);
-        }
-        if (containsInsensitive(normalizedLink, normalizedRequestedName)) {
-            score = std::max(score, 800);
-        }
-    }
-
-    if (!normalizedRequestedId.empty()) {
-        if (containsInsensitive(normalizedLink, normalizedRequestedId)) {
-            score = std::max(score, 700);
-        }
-        if (containsInsensitive(normalizedName, normalizedRequestedId)) {
-            score = std::max(score, 600);
-        }
-    }
-
-    return score;
-}
-
 } // namespace
 
 WebcamCapture::~WebcamCapture() {
@@ -157,53 +48,48 @@ bool WebcamCapture::initialize(
     int requestedWidth,
     int requestedHeight,
     int requestedFps,
-    bool preferNv12) {
+    bool preferNv12,
+    DeviceClaims& claims) {
     fps_ = std::clamp(requestedFps > 0 ? requestedFps : 30, 1, 60);
     usingDirectShow_ = false;
-    selectedMatchScore_ = 0;
-    if (!succeeded(MFStartup(MF_VERSION), "MFStartup(webcam)")) {
-        if (directShowCapture_.initialize(deviceId, deviceName, directShowClsid, requestedWidth, requestedHeight, fps_)) {
-            usingDirectShow_ = true;
-            return true;
+    selectedIdentity_.clear();
+    const auto initializeDirectShow = [&]() {
+        if (!directShowCapture_.initialize(
+                deviceId, deviceName, directShowClsid, requestedWidth, requestedHeight, fps_, claims)) {
+            if (!deviceId.empty() || !deviceName.empty()) {
+                std::cerr << "ERROR: Requested webcam device was not found by native Windows webcam providers"
+                          << std::endl;
+            }
+            return false;
         }
-        return false;
+        usingDirectShow_ = true;
+        claims.add(directShowCapture_.deviceIdentity());
+        return true;
+    };
+
+    if (!succeeded(MFStartup(MF_VERSION), "MFStartup(webcam)")) {
+        return initializeDirectShow();
     }
     mfStarted_ = true;
-    if (!selectDevice(deviceId, deviceName)) {
+    if (!selectDevice(deviceId, deviceName, claims)) {
         if (mfStarted_) {
             MFShutdown();
             mfStarted_ = false;
         }
-        if (directShowCapture_.initialize(deviceId, deviceName, directShowClsid, requestedWidth, requestedHeight, fps_)) {
-            usingDirectShow_ = true;
-            return true;
-        }
-        return false;
+        return initializeDirectShow();
     }
 
-    if ((!deviceId.empty() || !deviceName.empty()) && selectedMatchScore_ <= 0) {
-        if (mediaSource_) {
-            mediaSource_->Shutdown();
-        }
-        sourceReader_.Reset();
-        mediaSource_.Reset();
-        if (mfStarted_) {
-            MFShutdown();
-            mfStarted_ = false;
-        }
-        if (directShowCapture_.initialize(deviceId, deviceName, directShowClsid, requestedWidth, requestedHeight, fps_)) {
-            usingDirectShow_ = true;
-            return true;
-        }
-        std::cerr << "ERROR: Requested webcam device was not found by native Windows webcam providers"
-                  << std::endl;
+    if (!configureReader(requestedWidth, requestedHeight, fps_, preferNv12)) {
         return false;
     }
-
-    return configureReader(requestedWidth, requestedHeight, fps_, preferNv12);
+    claims.add(selectedIdentity_);
+    return true;
 }
 
-bool WebcamCapture::selectDevice(const std::wstring& deviceId, const std::wstring& deviceName) {
+bool WebcamCapture::selectDevice(
+    const std::wstring& deviceId,
+    const std::wstring& deviceName,
+    const DeviceClaims& claims) {
     Microsoft::WRL::ComPtr<IMFAttributes> attributes;
     if (!succeeded(MFCreateAttributes(&attributes, 1), "MFCreateAttributes(webcam enumeration)")) {
         return false;
@@ -226,34 +112,40 @@ bool WebcamCapture::selectDevice(const std::wstring& deviceId, const std::wstrin
         return false;
     }
 
-    UINT32 selectedIndex = 0;
-    int bestScore = 0;
+    std::vector<DeviceCandidate> candidates;
+    candidates.reserve(deviceCount);
+    bool anyClaimed = false;
     for (UINT32 index = 0; index < deviceCount; index += 1) {
-        const std::wstring name = readAllocatedString(devices[index], MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME);
-        const std::wstring symbolicLink = readAllocatedString(devices[index], MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK);
-        const int score = deviceMatchScore(name, symbolicLink, deviceName, deviceId);
-        std::wcerr << L"INFO: Native webcam candidate [" << index << L"] name=\"" << name << L"\" score=" << score << std::endl;
-        if (score > bestScore) {
-            selectedIndex = index;
-            bestScore = score;
-        }
-    }
-
-    if ((!deviceId.empty() || !deviceName.empty()) && bestScore <= 0) {
+        DeviceCandidate candidate{
+            readAllocatedString(devices[index], MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME),
+            readAllocatedString(devices[index], MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK)};
+        const bool claimed = claims.contains(candidate.identity);
+        anyClaimed = anyClaimed || claimed;
+        std::wcerr << L"INFO: Native webcam candidate [" << index << L"] name=\"" << candidate.name
+                   << L"\" score=" << deviceMatchScore(candidate.name, candidate.identity, deviceName, deviceId)
+                   << (claimed ? L" (already recording in this take)" : L"") << std::endl;
+        candidates.push_back(std::move(candidate));
+    }
+
+    const int selectedIndex = selectUnclaimedDevice(candidates, deviceName, deviceId, claims);
+    if (selectedIndex >= 0) {
+        selectedDeviceName_ = candidates[selectedIndex].name;
+        selectedIdentity_ = candidates[selectedIndex].identity;
+        hr = devices[selectedIndex]->ActivateObject(IID_PPV_ARGS(&mediaSource_));
+    } else if (anyClaimed) {
+        std::cerr << "WARNING: Every matching webcam is already recording in this take; trying DirectShow"
+                  << std::endl;
+    } else {
         std::cerr << "WARNING: Requested webcam device was not found by Media Foundation; trying DirectShow"
                   << std::endl;
     }
 
-    selectedMatchScore_ = bestScore;
-    selectedDeviceName_ = readAllocatedString(devices[selectedIndex], MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME);
-    hr = devices[selectedIndex]->ActivateObject(IID_PPV_ARGS(&mediaSource_));
-
     for (UINT32 index = 0; index < deviceCount; index += 1) {
         devices[index]->Release();
     }
     CoTaskMemFree(devices);
 
-    return succeeded(hr, "ActivateObject(webcam)");
+    return selectedIndex >= 0 && succeeded(hr, "ActivateObject(webcam)");
 }
 
 namespace {
diff --git a/electron/native/wgc-capture/src/webcam_capture.h b/electron/native/wgc-capture/src/webcam_capture.h
index 949282bf9..1d9e1fe5f 100644
--- a/electron/native/wgc-capture/src/webcam_capture.h
+++ b/electron/native/wgc-capture/src/webcam_capture.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "device_selection.h"
 #include "dshow_webcam_capture.h"
 
 #include <Windows.h>
@@ -22,6 +23,14 @@ class WebcamCapture {
     WebcamCapture(const WebcamCapture&) = delete;
     WebcamCapture& operator=(const WebcamCapture&) = delete;
 
+    /**
+     * Opens the requested camera, skipping devices in `claims`.
+     *
+     * `claims` belongs to the take: every camera of it is initialized against
+     * the same set, in config order, and one that opens adds its device. That
+     * is what sends a second camera of the same model to the second device
+     * instead of the busy first one. An empty set selects exactly as before.
+     */
     bool initialize(
         const std::wstring& deviceId,
         const std::wstring& deviceName,
@@ -29,7 +38,8 @@ class WebcamCapture {
         int requestedWidth,
         int requestedHeight,
         int requestedFps,
-        bool preferNv12);
+        bool preferNv12,
+        DeviceClaims& claims);
     bool start();
     void stop();
     bool copyLatestFrame(WebcamFrameSnapshot& destination, uint64_t lastSeenSequence);
@@ -48,7 +58,10 @@ class WebcamCapture {
     const std::wstring& selectedDeviceName() const;
 
 private:
-    bool selectDevice(const std::wstring& deviceId, const std::wstring& deviceName);
+    bool selectDevice(
+        const std::wstring& deviceId,
+        const std::wstring& deviceName,
+        const DeviceClaims& claims);
     bool configureReader(int requestedWidth, int requestedHeight, int requestedFps, bool preferNv12);
     void captureLoop();
 
@@ -86,6 +99,7 @@ class WebcamCapture {
     /** Where the loop's wall time goes, in microseconds. */
     uint64_t readSampleUs_ = 0;
     uint64_t storeUs_ = 0;
-    int selectedMatchScore_ = 0;
     std::wstring selectedDeviceName_;
+    /** The symbolic link of the device this capture opened, for the take's claims. */
+    std::wstring selectedIdentity_;
 };
diff --git a/scripts/build-windows-wgc-helper.mjs b/scripts/build-windows-wgc-helper.mjs
index 143fa689c..8f687dae9 100644
--- a/scripts/build-windows-wgc-helper.mjs
+++ b/scripts/build-windows-wgc-helper.mjs
@@ -124,6 +124,14 @@ if (!fs.existsSync(webcamConfigTestPath)) {
 await run(webcamConfigTestPath, [], { cwd: BUILD_DIR });
 console.log(`Passed ${webcamConfigTestPath}`);
 
+const deviceSelectionTestPath = path.join(BUILD_DIR, "device_selection_test.exe");
+if (!fs.existsSync(deviceSelectionTestPath)) {
+	throw new Error(`WGC helper build completed but ${deviceSelectionTestPath} was not found.`);
+}
+// Guards that two cameras of the same model in one take open two devices, not one twice.
+await run(deviceSelectionTestPath, [], { cwd: BUILD_DIR });
+console.log(`Passed ${deviceSelectionTestPath}`);
+
 const frameVisibilityTestPath = path.join(BUILD_DIR, "frame_visibility_test.exe");
 if (!fs.existsSync(frameVisibilityTestPath)) {
 	throw new Error(`WGC helper build completed but ${frameVisibilityTestPath} was not found.`);

From e45dad0fea4aae84d6c1dab76ccbd94116287d4f Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 12:19:19 +0200
Subject: [PATCH 08/22] fix(recording): tell cameras with the same name apart

A label already used by camera 1 or an earlier extra gets " (2)", " (3)" by occurrence, so unavailable and dropped cameras of the same model can be told apart.
---
 electron/electron-env.d.ts                    |  5 ++--
 electron/ipc/handlers.ts                      | 27 ++++++++++---------
 .../recording/nativeWindowsWebcams.test.ts    | 23 ++++++++++++++++
 electron/recording/nativeWindowsWebcams.ts    | 26 ++++++++++++++++++
 src/lib/nativeWindowsRecording.ts             |  5 ++--
 5 files changed, 70 insertions(+), 16 deletions(-)

diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.ts
index f0ed35c2f..99b2a3f79 100644
--- a/electron/electron-env.d.ts
+++ b/electron/electron-env.d.ts
@@ -178,8 +178,9 @@ interface Window {
 			 */
 			webcamDropped?: boolean;
 			/**
-			 * Device names of additional cameras (2-4) that produced nothing usable
-			 * and were left out of the session. Camera 1 is `webcamDropped`.
+			 * Labels (device name, else `Camera <n>`) of additional cameras (2-4) that
+			 * produced nothing usable and were left out of the session. Camera 1 is
+			 * `webcamDropped`.
 			 */
 			droppedWebcams?: string[];
 		}>;
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index 835a7a231..097d97706 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -131,6 +131,7 @@ import {
 	waitForNativeWindowsCaptureStop,
 } from "../recording/nativeWindowsCaptureStop";
 import {
+	additionalWebcamLabels,
 	buildHelperWebcamConfig,
 	collectStoppedWebcams,
 	dedupeAdditionalWebcams,
@@ -2891,20 +2892,22 @@ export function registerIpcHandlers(
 					: null;
 				// Cameras 2-4 only while camera 1 is on: its toggle governs every
 				// camera. Files are numbered from 2 in the order they are sent.
-				const additionalWebcams = request.webcam.enabled
-					? await Promise.all(
-							dedupeAdditionalWebcams(
-								request.webcam,
-								Array.isArray(request.additionalWebcams) ? request.additionalWebcams : [],
-							).map(async (extra, i) => ({
-								deviceId: extra.deviceId,
-								deviceName: extra.deviceName,
-								label: extra.deviceName?.trim() || `Camera ${i + 2}`,
-								clsid: await resolveDirectShowWebcamClsid(extra.deviceName),
-								path: webcamOutputPath(RECORDINGS_DIR, RECORDING_FILE_PREFIX, recordingId, i + 2),
-							})),
+				const keptExtras = request.webcam.enabled
+					? dedupeAdditionalWebcams(
+							request.webcam,
+							Array.isArray(request.additionalWebcams) ? request.additionalWebcams : [],
 						)
 					: [];
+				const extraLabels = additionalWebcamLabels(request.webcam.deviceName, keptExtras);
+				const additionalWebcams = await Promise.all(
+					keptExtras.map(async (extra, i) => ({
+						deviceId: extra.deviceId,
+						deviceName: extra.deviceName,
+						label: extraLabels[i],
+						clsid: await resolveDirectShowWebcamClsid(extra.deviceName),
+						path: webcamOutputPath(RECORDINGS_DIR, RECORDING_FILE_PREFIX, recordingId, i + 2),
+					})),
+				);
 				const cursorCaptureMode =
 					normalizeCursorCaptureMode(request.cursor?.mode) ?? "editable-overlay";
 				const envPreferSoftwareEncoder = (process.env.OPENSCREEN_WGC_PREFER_SOFTWARE_ENCODER ?? "")
diff --git a/electron/recording/nativeWindowsWebcams.test.ts b/electron/recording/nativeWindowsWebcams.test.ts
index bb4e7c039..ffd0ea56e 100644
--- a/electron/recording/nativeWindowsWebcams.test.ts
+++ b/electron/recording/nativeWindowsWebcams.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 import {
+	additionalWebcamLabels,
 	buildHelperWebcamConfig,
 	collectStoppedWebcams,
 	dedupeAdditionalWebcams,
@@ -118,6 +119,28 @@ describe("nativeWindowsWebcams", () => {
 		expect(labelsOfUnavailableAdditionalWebcams(requested, [0, 2, 2, 9])).toEqual(["Side"]);
 	});
 
+	it("labels extras by device name, else Camera <n>", () => {
+		expect(additionalWebcamLabels("Front", [{ deviceName: "Desk" }, { deviceName: "  " }])).toEqual(
+			["Desk", "Camera 3"],
+		);
+	});
+
+	it("tells cameras with the same name apart by occurrence, counting camera 1", () => {
+		expect(
+			additionalWebcamLabels("USB Camera", [
+				{ deviceName: "USB Camera" },
+				{ deviceName: "Desk" },
+				{ deviceName: " USB Camera " },
+			]),
+		).toEqual(["USB Camera (2)", "Desk", "USB Camera (3)"]);
+		expect(
+			additionalWebcamLabels(undefined, [
+				{ deviceName: "USB Camera" },
+				{ deviceName: "USB Camera" },
+			]),
+		).toEqual(["USB Camera", "USB Camera (2)"]);
+	});
+
 	it("builds a start config with the legacy fields and a list of every camera", () => {
 		const config = buildHelperWebcamConfig({
 			camera1: {
diff --git a/electron/recording/nativeWindowsWebcams.ts b/electron/recording/nativeWindowsWebcams.ts
index 42e87365a..08a797082 100644
--- a/electron/recording/nativeWindowsWebcams.ts
+++ b/electron/recording/nativeWindowsWebcams.ts
@@ -92,6 +92,32 @@ export function dedupeAdditionalWebcams<T extends { deviceId?: string; deviceNam
 	return kept;
 }
 
+/**
+ * Labels of the additional cameras, in order: the device name, else
+ * `Camera <n>` (n counts camera 1, so the first extra is camera 2).
+ *
+ * Two webcams of the same model report the same name, and a label is all the
+ * user is told about a camera that could not be opened or was dropped. So a
+ * label already used — by camera 1 or an earlier extra — gets " (2)", " (3)"
+ * by occurrence. Camera 1's own label is never changed.
+ */
+export function additionalWebcamLabels(
+	camera1Name: string | undefined,
+	extras: Array<{ deviceName: string }>,
+): string[] {
+	const seen = new Map<string, number>();
+	const camera1Label = camera1Name?.trim();
+	if (camera1Label) {
+		seen.set(camera1Label, 1);
+	}
+	return extras.map((extra, i) => {
+		const label = extra.deviceName.trim() || `Camera ${i + 2}`;
+		const occurrence = (seen.get(label) ?? 0) + 1;
+		seen.set(label, occurrence);
+		return occurrence > 1 ? `${label} (${occurrence})` : label;
+	});
+}
+
 /**
  * The camera part of the helper config: the unchanged legacy `webcam*` fields
  * for camera 1 plus the `webcams` list (camera 1 first, then the extras).
diff --git a/src/lib/nativeWindowsRecording.ts b/src/lib/nativeWindowsRecording.ts
index c014cf243..b5924f84f 100644
--- a/src/lib/nativeWindowsRecording.ts
+++ b/src/lib/nativeWindowsRecording.ts
@@ -66,8 +66,9 @@ export type NativeWindowsRecordingStartResult = {
 	 */
 	webcamUnavailable?: boolean;
 	/**
-	 * Device names of additional cameras (2-4) the helper could not open; this
-	 * take records without them. Camera 1 is reported by `webcamUnavailable`.
+	 * Labels (device name, else `Camera <n>`) of additional cameras (2-4) the
+	 * helper could not open; this take records without them. Camera 1 is
+	 * reported by `webcamUnavailable`.
 	 */
 	unavailableWebcams?: string[];
 	/**

From 1a419933d44fc4a2ad00dc134500f5a377e0484a Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 12:29:22 +0200
Subject: [PATCH 09/22] feat(project): keep a recording's additional cameras

---
 electron/media/projectMediaRelinker.test.ts   | 48 ++++++++++++
 electron/media/projectMediaRelinker.ts        | 29 ++++++-
 src/lib/ai-edition/schema/index.test.ts       | 28 +++++++
 src/lib/ai-edition/schema/index.ts            | 18 +++++
 src/lib/ai-edition/store/projectStore.test.ts | 76 +++++++++++++++++++
 src/lib/ai-edition/store/projectStore.ts      | 23 +++++-
 6 files changed, 220 insertions(+), 2 deletions(-)

diff --git a/electron/media/projectMediaRelinker.test.ts b/electron/media/projectMediaRelinker.test.ts
index 2b52d32b5..505a430f4 100644
--- a/electron/media/projectMediaRelinker.test.ts
+++ b/electron/media/projectMediaRelinker.test.ts
@@ -62,6 +62,54 @@ describe("relinkProjectMedia", () => {
 		expect(logged.join("\n")).toContain(currentWebcamPath);
 	});
 
+	it("relinks additional cameras by index and leaves absent ones alone", async () => {
+		const currentScreenPath = path.join(tempDir, "recording-43.mp4");
+		const currentWebcamPath = path.join(tempDir, "recording-43-webcam.mp4");
+		const currentExtra2 = path.join(tempDir, "recording-43-webcam-2.mp4");
+		const currentExtra3 = path.join(tempDir, "recording-43-webcam-3.mp4");
+		await fs.writeFile(currentScreenPath, "screen bytes");
+		await fs.writeFile(currentWebcamPath, "webcam bytes");
+		await fs.writeFile(currentExtra2, "extra 2");
+		await fs.writeFile(currentExtra3, "extra 3");
+		await registerMediaLinks(tempDir, currentScreenPath, {
+			webcamVideoPath: currentWebcamPath,
+			additionalWebcams: [
+				{ path: currentExtra2, label: "Desk" },
+				{ path: currentExtra3, label: "Wide" },
+			],
+		});
+
+		const project = {
+			assets: [
+				{
+					id: "asset-1",
+					originalPath: "C:\\Users\\demo\\recording-43.mp4",
+					sizeBytes: Buffer.byteLength("screen bytes"),
+					cameraTrack: {
+						sourcePath: "C:\\Users\\demo\\recording-43-webcam.mp4",
+						startMs: 0,
+						offsetMs: 0,
+						visible: true,
+					},
+					additionalCameraTracks: [
+						{ sourcePath: "C:\\Users\\demo\\recording-43-webcam-2.mp4", label: "Desk" },
+						{ sourcePath: "C:\\Users\\demo\\recording-43-webcam-3.mp4", label: "Wide" },
+					],
+				},
+			],
+		};
+
+		const relinked = (await relinkProjectMedia(project, tempDir)) as typeof project;
+
+		expect(relinked.assets[0].cameraTrack.sourcePath).toBe(currentWebcamPath);
+		expect(relinked.assets[0].additionalCameraTracks.map((t) => t.sourcePath)).toEqual([
+			currentExtra2,
+			currentExtra3,
+		]);
+		expect(relinked.assets[0].additionalCameraTracks.map((t) => t.label)).toEqual(["Desk", "Wide"]);
+		expect(project.assets[0].additionalCameraTracks[0].sourcePath).toContain("demo");
+	});
+
 	it("refuses to relink an asset the document recorded no size for", async () => {
 		// A same-named recording exists and is registered with its webcam, so a
 		// basename match would resolve — that is exactly what must not happen. The
diff --git a/electron/media/projectMediaRelinker.ts b/electron/media/projectMediaRelinker.ts
index 0c0b8c259..bef7dad02 100644
--- a/electron/media/projectMediaRelinker.ts
+++ b/electron/media/projectMediaRelinker.ts
@@ -41,11 +41,23 @@ async function resolveAssetMedia(
 		isRecord(cameraTrack) && typeof cameraTrack.sourcePath === "string" && cameraTrack.sourcePath
 			? cameraTrack.sourcePath
 			: null;
+	const additionalTracks = Array.isArray(asset.additionalCameraTracks)
+		? asset.additionalCameraTracks
+		: [];
+	const additionalMissing = await Promise.all(
+		additionalTracks.map(
+			async (track) =>
+				isRecord(track) &&
+				typeof track.sourcePath === "string" &&
+				track.sourcePath !== "" &&
+				!(await fileExists(track.sourcePath)),
+		),
+	);
 	const screenExists = await fileExists(originalPath);
 	const cameraMissing = cameraPath !== null && !(await fileExists(cameraPath));
 	// Nothing to repair, and this runs on every project open — don't fingerprint
 	// (i.e. open and read) every asset just to confirm what the stats already say.
-	if (screenExists && !cameraMissing) return asset;
+	if (screenExists && !cameraMissing && !additionalMissing.some(Boolean)) return asset;
 
 	let links: RelocatedMediaLookup | null = null;
 	if (screenExists) {
@@ -81,10 +93,25 @@ async function resolveAssetMedia(
 		nextCameraTrack = { ...cameraTrack, sourcePath: links.webcamVideoPath };
 	}
 
+	// Extras are matched by index, the same order the recording registered them in.
+	let additionalChanged = false;
+	const nextAdditionalTracks = await Promise.all(
+		additionalTracks.map(async (track, index) => {
+			const replacement = links.additionalWebcams?.[index]?.path;
+			if (!additionalMissing[index] || !replacement || !(await fileExists(replacement))) {
+				return track;
+			}
+			console.log(`[media-relink] additional webcam ${index + 2} -> ${replacement}`);
+			additionalChanged = true;
+			return { ...track, sourcePath: replacement };
+		}),
+	);
+
 	return {
 		...asset,
 		originalPath: links.screenVideoPath,
 		...(nextCameraTrack === cameraTrack ? {} : { cameraTrack: nextCameraTrack }),
+		...(additionalChanged ? { additionalCameraTracks: nextAdditionalTracks } : {}),
 	};
 }
 
diff --git a/src/lib/ai-edition/schema/index.test.ts b/src/lib/ai-edition/schema/index.test.ts
index 38aabd870..bb8148e9c 100644
--- a/src/lib/ai-edition/schema/index.test.ts
+++ b/src/lib/ai-edition/schema/index.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { migrateRawDocumentToCurrent } from "../document/migrate";
 import {
+	additionalCameraTrackSchema,
 	annotationRegionSchema,
 	assetSchema,
 	audioTrackSchema,
@@ -275,6 +276,33 @@ describe("axcut-schema v8", () => {
 		).not.toThrow();
 	});
 
+	describe("additionalCameraTracks", () => {
+		const base = { id: "asset_1", kind: "video", label: "x", originalPath: "/x.mp4" };
+
+		it("leaves an asset without the key untouched", () => {
+			expect(assetSchema.parse(base)).not.toHaveProperty("additionalCameraTracks");
+		});
+
+		it("fills defaults on each entry", () => {
+			const asset = assetSchema.parse({
+				...base,
+				additionalCameraTracks: [{ sourcePath: "/a.mp4" }, { sourcePath: "/b.mp4", label: "Desk" }],
+			});
+			expect(asset.additionalCameraTracks).toEqual([
+				{ sourcePath: "/a.mp4", startMs: 0, offsetMs: 0, visible: true, label: "" },
+				{ sourcePath: "/b.mp4", startMs: 0, offsetMs: 0, visible: true, label: "Desk" },
+			]);
+			expect(additionalCameraTrackSchema.safeParse({ sourcePath: "" }).success).toBe(false);
+		});
+
+		it("rejects more than three additional cameras", () => {
+			const entries = Array.from({ length: 5 }, (_, i) => ({ sourcePath: `/c${i}.mp4` }));
+			expect(assetSchema.safeParse({ ...base, additionalCameraTracks: entries }).success).toBe(
+				false,
+			);
+		});
+	});
+
 	it("assetSchema defaults cameraTrack to null", () => {
 		const asset = assetSchema.parse({
 			id: "asset_1",
diff --git a/src/lib/ai-edition/schema/index.ts b/src/lib/ai-edition/schema/index.ts
index 9c5760f19..02702afc1 100644
--- a/src/lib/ai-edition/schema/index.ts
+++ b/src/lib/ai-edition/schema/index.ts
@@ -156,6 +156,23 @@ export const cameraTrackSchema = z
 	.nullable()
 	.default(null);
 
+// Cameras 2-4 of a multi-camera recording. Camera 1 stays `cameraTrack`; these only
+// store the extra files (the editor still shows camera 1) and mirror its fields.
+//
+// Optional and absent on every document written before multi-camera recording,
+// exactly like `cameraTrack.width`: additive, so no schema-version bump, and an
+// older build simply drops the key on save.
+export const additionalCameraTrackSchema = z.object({
+	sourcePath: z.string().min(1),
+	startMs: z.number().nonnegative().default(0),
+	offsetMs: z.number().int().default(0),
+	visible: z.boolean().default(true),
+	width: z.number().int().positive().optional(),
+	height: z.number().int().positive().optional(),
+	label: z.string().default(""),
+});
+export type AxcutAdditionalCameraTrack = z.infer<typeof additionalCameraTrackSchema>;
+
 // Why a media can never be transcribed. Only the DETERMINISTIC verdicts live
 // here: a container with no audio track (a screen recording captured with no
 // mic and no system audio — the common case) fails identically on every
@@ -190,6 +207,7 @@ export const assetSchema = z.object({
 	// no schema-version bump (an older build simply drops the key on save).
 	transcriptionFailure: assetTranscriptionFailureSchema.nullish(),
 	cameraTrack: cameraTrackSchema,
+	additionalCameraTracks: z.array(additionalCameraTrackSchema).max(3).optional(),
 });
 
 // A crop is a sub-rectangle of the source video, expressed as fractions
diff --git a/src/lib/ai-edition/store/projectStore.test.ts b/src/lib/ai-edition/store/projectStore.test.ts
index b49bae656..ce3daf45d 100644
--- a/src/lib/ai-edition/store/projectStore.test.ts
+++ b/src/lib/ai-edition/store/projectStore.test.ts
@@ -251,6 +251,82 @@ describe("useProjectStore", () => {
 		expect(camera?.offsetMs).toBe(-193);
 	});
 
+	it("addAsset keeps a recording's additional cameras beside camera 1", async () => {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: sampleDoc,
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+		bridgeMocks.save.mockImplementation(async (document) => ({ success: true, document }));
+		// biome-ignore lint/suspicious/noExplicitAny: test-only stub of the legacy contextBridge surface
+		(window as any).electronAPI.findRecordingCamera.mockResolvedValue({
+			success: true,
+			webcamVideoPath: "/w.mp4",
+			offsetMs: 0,
+			additionalWebcams: [{ path: "/w-2.mp4", label: "Desk" }],
+		});
+		bridgeMocks.addAsset.mockResolvedValue({
+			assetId: "asset_1",
+			document: {
+				...sampleDoc,
+				assets: [
+					{ id: "asset_1", kind: "video", label: "screen.mp4", originalPath: "/tmp/screen.mp4" },
+				],
+				project: { ...sampleDoc.project, primaryAssetId: "asset_1" },
+			},
+		});
+
+		await useProjectStore.getState().addAsset("/tmp/screen.mp4");
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const asset = useProjectStore.getState().document?.assets[0];
+		expect(asset?.cameraTrack?.sourcePath).toBe("/w.mp4");
+		expect(asset?.additionalCameraTracks).toHaveLength(1);
+		expect(asset?.additionalCameraTracks?.[0]).toMatchObject({
+			sourcePath: "/w-2.mp4",
+			label: "Desk",
+			startMs: 0,
+			offsetMs: 0,
+			visible: true,
+		});
+	});
+
+	it("addAsset adds no additionalCameraTracks key when the recording has no extras", async () => {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: sampleDoc,
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+		bridgeMocks.save.mockImplementation(async (document) => ({ success: true, document }));
+		// biome-ignore lint/suspicious/noExplicitAny: test-only stub of the legacy contextBridge surface
+		(window as any).electronAPI.findRecordingCamera.mockResolvedValue({
+			success: true,
+			webcamVideoPath: "/w.mp4",
+			offsetMs: 0,
+		});
+		bridgeMocks.addAsset.mockResolvedValue({
+			assetId: "asset_1",
+			document: {
+				...sampleDoc,
+				assets: [
+					{ id: "asset_1", kind: "video", label: "screen.mp4", originalPath: "/tmp/screen.mp4" },
+				],
+				project: { ...sampleDoc.project, primaryAssetId: "asset_1" },
+			},
+		});
+
+		await useProjectStore.getState().addAsset("/tmp/screen.mp4");
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const asset = useProjectStore.getState().document?.assets[0];
+		expect(asset?.cameraTrack?.sourcePath).toBe("/w.mp4");
+		expect(asset).not.toHaveProperty("additionalCameraTracks");
+	});
+
 	it("addAsset stays silent (no toast) when a plain imported video has no camera", async () => {
 		useProjectStore.setState({
 			projectId: "proj_test",
diff --git a/src/lib/ai-edition/store/projectStore.ts b/src/lib/ai-edition/store/projectStore.ts
index ec60b230b..351989dd0 100644
--- a/src/lib/ai-edition/store/projectStore.ts
+++ b/src/lib/ai-edition/store/projectStore.ts
@@ -381,6 +381,21 @@ export const useProjectStore = create<ProjectState>((set, get) => ({
 					const camDims = await probeVideoDimensions(toFileUrl(camera.webcamVideoPath)).catch(
 						() => null,
 					);
+					// Cameras 2-4 get the same treatment as camera 1 (same T0 on Windows, so the
+					// same offset) and the same non-fatal dimension probe.
+					const extras = await Promise.all(
+						(camera.additionalWebcams ?? []).map(async (extra) => {
+							const dims = await probeVideoDimensions(toFileUrl(extra.path)).catch(() => null);
+							return {
+								sourcePath: extra.path,
+								label: extra.label,
+								startMs: 0,
+								offsetMs: Math.round(camera.offsetMs ?? 0),
+								visible: true,
+								...(dims ?? {}),
+							};
+						}),
+					);
 					const linked = {
 						sourcePath: camera.webcamVideoPath,
 						startMs: 0,
@@ -403,7 +418,13 @@ export const useProjectStore = create<ProjectState>((set, get) => ({
 					const next: AxcutDocument = {
 						...document,
 						assets: document.assets.map((a) =>
-							a.id === addedAsset.id ? { ...a, cameraTrack: linked } : a,
+							a.id === addedAsset.id
+								? {
+										...a,
+										cameraTrack: linked,
+										...(extras.length > 0 ? { additionalCameraTracks: extras } : {}),
+									}
+								: a,
 						),
 					};
 					// Only adopt the linked document if it actually reached disk -- otherwise

From aa84135dc27e2e9e11e4eda8c9910c8298fe3791 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 12:40:03 +0200
Subject: [PATCH 10/22] feat(hud): pick additional cameras for a Windows
 recording

---
 electron/app-settings.test.ts                 |  55 +++++++
 electron/app-settings.ts                      |  27 ++++
 electron/ipc/handlers.ts                      |   3 +
 electron/ipc/recordingPrefs.test.ts           |   1 +
 .../ai-edition/v4/EditorShellV4.module.css    |  44 ++++++
 .../ai-edition/v4/RecStage.test.tsx           |   2 +
 src/components/ai-edition/v4/RecStage.tsx     |  30 ++++
 .../launch/AdditionalCamerasList.test.tsx     | 137 ++++++++++++++++++
 .../launch/AdditionalCamerasList.tsx          |  99 +++++++++++++
 src/components/launch/HudDeviceSettings.tsx   |  26 ++++
 src/components/launch/LaunchWindow.module.css |  10 ++
 src/components/launch/LaunchWindow.tsx        |  40 +++++
 src/hooks/useNativeWindowsCaptureAvailable.ts |  27 ++++
 src/hooks/useScreenRecorder.noCamera.test.tsx |   1 +
 .../useScreenRecorder.prefsRace.test.tsx      |   1 +
 src/hooks/useScreenRecorder.ts                |  47 ++++++
 src/i18n/locales/ar/launch.json               |   3 +
 src/i18n/locales/cs/launch.json               |   3 +
 src/i18n/locales/de/launch.json               |   3 +
 src/i18n/locales/en/launch.json               |   3 +
 src/i18n/locales/es/launch.json               |   3 +
 src/i18n/locales/fr/launch.json               |   3 +
 src/i18n/locales/it/launch.json               |   3 +
 src/i18n/locales/ja-JP/launch.json            |   3 +
 src/i18n/locales/ko-KR/launch.json            |   3 +
 src/i18n/locales/pt-BR/launch.json            |   3 +
 src/i18n/locales/ru/launch.json               |   3 +
 src/i18n/locales/tr/launch.json               |   3 +
 src/i18n/locales/vi/launch.json               |   3 +
 src/i18n/locales/zh-CN/launch.json            |   3 +
 src/i18n/locales/zh-TW/launch.json            |   3 +
 src/lib/additionalWebcams.test.ts             |  60 ++++++++
 src/lib/additionalWebcams.ts                  |  36 +++++
 33 files changed, 691 insertions(+)
 create mode 100644 src/components/launch/AdditionalCamerasList.test.tsx
 create mode 100644 src/components/launch/AdditionalCamerasList.tsx
 create mode 100644 src/hooks/useNativeWindowsCaptureAvailable.ts
 create mode 100644 src/lib/additionalWebcams.test.ts
 create mode 100644 src/lib/additionalWebcams.ts

diff --git a/electron/app-settings.test.ts b/electron/app-settings.test.ts
index f3781734f..f7590fdb6 100644
--- a/electron/app-settings.test.ts
+++ b/electron/app-settings.test.ts
@@ -165,4 +165,59 @@ describe("app settings store", () => {
 
 		expect(new AppSettingsStore(dir).getSnapshot().recording.camQuality).toBe("2160p");
 	});
+
+	it("reads a missing additional camera list as empty", () => {
+		const dir = temp();
+		writeFileSync(
+			path.join(dir, "recording-settings.json"),
+			JSON.stringify({ camEnabled: true }),
+			"utf8",
+		);
+
+		expect(new AppSettingsStore(dir).getSnapshot().recording.camAdditionalDevices).toEqual([]);
+	});
+
+	it("drops additional camera entries without a name and keeps at most three", () => {
+		const store = new AppSettingsStore(temp());
+		store.setRecordingPreferences({
+			camAdditionalDevices: [
+				{ id: "a", name: "A" },
+				{ id: null, name: "B" },
+				{ id: "x", name: "" },
+				{ id: "c", name: "C" },
+				{ id: "d", name: "D" },
+				{ id: "e", name: "E" },
+			],
+		});
+
+		expect(store.getSnapshot().recording.camAdditionalDevices).toEqual([
+			{ id: "a", name: "A" },
+			{ id: null, name: "B" },
+			{ id: "c", name: "C" },
+		]);
+	});
+
+	it("ignores junk in a stored additional camera list", () => {
+		const dir = temp();
+		writeFileSync(
+			path.join(dir, "recording-settings.json"),
+			JSON.stringify({
+				camAdditionalDevices: [null, 3, "x", { name: 5 }, { id: 7, name: "Kept" }, { name: "Ok" }],
+			}),
+			"utf8",
+		);
+
+		expect(new AppSettingsStore(dir).getSnapshot().recording.camAdditionalDevices).toEqual([
+			{ id: null, name: "Kept" },
+			{ id: null, name: "Ok" },
+		]);
+	});
+
+	it("rejects an additional camera list that is not a list", () => {
+		const store = new AppSettingsStore(temp());
+
+		expect(() => store.setRecordingPreferences({ camAdditionalDevices: "x" as never })).toThrow(
+			TypeError,
+		);
+	});
 });
diff --git a/electron/app-settings.ts b/electron/app-settings.ts
index bef025bf3..d1efb9aae 100644
--- a/electron/app-settings.ts
+++ b/electron/app-settings.ts
@@ -15,6 +15,8 @@ export interface RecordingPreferences {
 	camEnabled: boolean;
 	camDeviceId: string | null;
 	camDeviceName: string | null;
+	/** Cameras 2-4 of a native Windows recording, in the order they were picked. At most three. */
+	camAdditionalDevices: Array<{ id: string | null; name: string }>;
 	/** Capture resolution for the camera. See WEBCAM_QUALITY_PRESETS. */
 	camQuality: WebcamQualityId;
 	systemAudioEnabled: boolean;
@@ -38,6 +40,7 @@ export const DEFAULT_RECORDING_PREFERENCES: RecordingPreferences = {
 	camEnabled: false,
 	camDeviceId: null,
 	camDeviceName: null,
+	camAdditionalDevices: [],
 	camQuality: DEFAULT_WEBCAM_QUALITY,
 	systemAudioEnabled: false,
 	cursorCaptureMode: "editable-overlay",
@@ -101,6 +104,22 @@ const bool = (value: unknown, fallback: boolean) => (typeof value === "boolean"
 const nullableString = (value: unknown, fallback: string | null) =>
 	value === null || typeof value === "string" ? value : fallback;
 
+const MAX_ADDITIONAL_CAMERAS = 3;
+
+/** Keeps the entries that name a camera, in order, up to the cap; everything else is junk. */
+function additionalCameras(value: unknown): RecordingPreferences["camAdditionalDevices"] {
+	if (!Array.isArray(value)) return [];
+	const kept: RecordingPreferences["camAdditionalDevices"] = [];
+	for (const entry of value) {
+		if (kept.length >= MAX_ADDITIONAL_CAMERAS) break;
+		if (!entry || typeof entry !== "object") continue;
+		const { id, name } = entry as Record<string, unknown>;
+		if (typeof name !== "string" || name.length === 0) continue;
+		kept.push({ id: typeof id === "string" ? id : null, name });
+	}
+	return kept;
+}
+
 function parseRecording(raw: RawSettings): RecordingPreferences {
 	return {
 		micEnabled: bool(raw.micEnabled, DEFAULT_RECORDING_PREFERENCES.micEnabled),
@@ -109,6 +128,7 @@ function parseRecording(raw: RawSettings): RecordingPreferences {
 		camEnabled: bool(raw.camEnabled, DEFAULT_RECORDING_PREFERENCES.camEnabled),
 		camDeviceId: nullableString(raw.camDeviceId, DEFAULT_RECORDING_PREFERENCES.camDeviceId),
 		camDeviceName: nullableString(raw.camDeviceName, DEFAULT_RECORDING_PREFERENCES.camDeviceName),
+		camAdditionalDevices: additionalCameras(raw.camAdditionalDevices),
 		// Unset in every settings file written before the camera had a quality
 		// setting, and `webcamQualityFrom` answers those with the default.
 		camQuality: webcamQualityFrom(raw.camQuality),
@@ -169,6 +189,10 @@ function validateRecordingPatch(patch: Partial<RecordingPreferences>): void {
 		if ((key.endsWith("Enabled") || key === "hideDesktopIcons") && typeof value !== "boolean") {
 			throw new TypeError(`${key} must be a boolean`);
 		}
+		if (key === "camAdditionalDevices") {
+			if (!Array.isArray(value)) throw new TypeError("camAdditionalDevices must be a list");
+			continue;
+		}
 		if (
 			(key.endsWith("DeviceId") || key.endsWith("DeviceName")) &&
 			value !== null &&
@@ -207,6 +231,9 @@ export class AppSettingsStore {
 		const next = Object.fromEntries(
 			Object.entries(patch).filter(([, value]) => value !== undefined),
 		) as Partial<RecordingPreferences>;
+		if (next.camAdditionalDevices) {
+			next.camAdditionalDevices = additionalCameras(next.camAdditionalDevices);
+		}
 		atomicWrite(this.userData, { ...raw, ...current, ...next });
 		return this.getSnapshot();
 	}
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index 097d97706..191250fcd 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -686,6 +686,8 @@ export interface RecordingPrefs {
 	camDeviceId: string | null;
 	/** Camera label paired with the preferred id for restart-safe resolution. */
 	camDeviceName: string | null;
+	/** Cameras 2-4 of a native Windows recording, in pick order. At most three. */
+	camAdditionalDevices: Array<{ id: string | null; name: string }>;
 	/** Capture resolution for the camera. See WEBCAM_QUALITY_PRESETS. */
 	camQuality: WebcamQualityId;
 	systemAudioEnabled: boolean;
@@ -701,6 +703,7 @@ const defaultRecordingPrefs: RecordingPrefs = {
 	camEnabled: false,
 	camDeviceId: null,
 	camDeviceName: null,
+	camAdditionalDevices: [],
 	camQuality: DEFAULT_WEBCAM_QUALITY,
 	systemAudioEnabled: false,
 	cursorCaptureMode: "editable-overlay",
diff --git a/electron/ipc/recordingPrefs.test.ts b/electron/ipc/recordingPrefs.test.ts
index 2c3317af9..7d2d056a1 100644
--- a/electron/ipc/recordingPrefs.test.ts
+++ b/electron/ipc/recordingPrefs.test.ts
@@ -19,6 +19,7 @@ const defaults: RecordingPrefs = {
 	camEnabled: false,
 	camDeviceId: null,
 	camDeviceName: null,
+	camAdditionalDevices: [],
 	camQuality: "2160p",
 	systemAudioEnabled: false,
 	cursorCaptureMode: "editable-overlay",
diff --git a/src/components/ai-edition/v4/EditorShellV4.module.css b/src/components/ai-edition/v4/EditorShellV4.module.css
index ee3d11fab..b4a1449cc 100644
--- a/src/components/ai-edition/v4/EditorShellV4.module.css
+++ b/src/components/ai-edition/v4/EditorShellV4.module.css
@@ -1000,6 +1000,50 @@
 	border-color: var(--border-hi);
 	background: var(--surface-2);
 }
+/* Cameras 2-4, under the camera row: one checkbox line per extra camera. */
+.recExtraCams {
+	display: flex;
+	flex-direction: column;
+	gap: 2px;
+	padding: 10px 16px 13px;
+	border-bottom: 1px solid var(--border-soft);
+}
+.recExtraCamsTitle {
+	color: var(--fg-2);
+	font-size: 13px;
+	font-weight: 500;
+	margin-bottom: 4px;
+}
+.recExtraCam {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: 8px;
+	padding: 6px 10px;
+	border: 1px solid var(--border);
+	border-radius: 9px;
+	background: var(--surface-hi);
+	color: var(--fg);
+	font-size: 12.5px;
+	cursor: pointer;
+	text-align: left;
+}
+.recExtraCam:hover:not(:disabled) {
+	border-color: var(--border-hi);
+	background: var(--surface-2);
+}
+.recExtraCam:disabled {
+	opacity: 0.45;
+	cursor: not-allowed;
+}
+.recExtraCamOn {
+	border-color: var(--border-hi);
+}
+.recExtraCamsHint {
+	color: var(--muted);
+	font-size: 12px;
+	margin-top: 4px;
+}
 .recSelect {
 	height: 32px;
 	max-width: 200px;
diff --git a/src/components/ai-edition/v4/RecStage.test.tsx b/src/components/ai-edition/v4/RecStage.test.tsx
index b79308df3..58af434b1 100644
--- a/src/components/ai-edition/v4/RecStage.test.tsx
+++ b/src/components/ai-edition/v4/RecStage.test.tsx
@@ -290,6 +290,7 @@ describe("RecStage controls", () => {
 			camEnabled: false,
 			camDeviceId: null,
 			camDeviceName: null,
+			camAdditionalDevices: [],
 			camQuality: "2160p",
 			systemAudioEnabled: false,
 			cursorCaptureMode: "editable-overlay",
@@ -501,6 +502,7 @@ describe("RecStage controls", () => {
 			camEnabled: false,
 			camDeviceId: null,
 			camDeviceName: null,
+			camAdditionalDevices: [],
 			camQuality: "2160p",
 			systemAudioEnabled: false,
 			cursorCaptureMode: "editable-overlay",
diff --git a/src/components/ai-edition/v4/RecStage.tsx b/src/components/ai-edition/v4/RecStage.tsx
index 658ed6b4d..6f488f444 100644
--- a/src/components/ai-edition/v4/RecStage.tsx
+++ b/src/components/ai-edition/v4/RecStage.tsx
@@ -13,6 +13,7 @@ import {
 	ZoomIn,
 } from "lucide-react";
 import { useEffect, useId, useRef, useState } from "react";
+import { AdditionalCamerasList } from "@/components/launch/AdditionalCamerasList";
 import { AudioLevelMeter } from "@/components/ui/audio-level-meter";
 import { Tooltip } from "@/components/ui/tooltip";
 import { useScopedT } from "@/contexts/I18nContext";
@@ -21,6 +22,7 @@ import { useCameraDevices } from "@/hooks/useCameraDevices";
 import { useCameraPreviewStream } from "@/hooks/useCameraPreviewStream";
 import { useEditableCursorAvailable } from "@/hooks/useEditableCursorAvailable";
 import { useMicrophoneDevices } from "@/hooks/useMicrophoneDevices";
+import { useNativeWindowsCaptureAvailable } from "@/hooks/useNativeWindowsCaptureAvailable";
 import { usePortalOwnsSource } from "@/hooks/usePortalOwnsSource";
 import { canRecordMicrophone, getPlatform } from "@/utils/platformUtils";
 import styles from "./EditorShellV4.module.css";
@@ -32,6 +34,7 @@ interface RecordingPrefsState {
 	camEnabled: boolean;
 	camDeviceId: string | null;
 	camDeviceName: string | null;
+	camAdditionalDevices: Array<{ id: string | null; name: string }>;
 	systemAudioEnabled: boolean;
 	cursorCaptureMode: "editable-overlay" | "system";
 	hideDesktopIcons: boolean;
@@ -45,6 +48,7 @@ const DEFAULT_PREFS: RecordingPrefsState = {
 	camEnabled: false,
 	camDeviceId: null,
 	camDeviceName: null,
+	camAdditionalDevices: [],
 	systemAudioEnabled: false,
 	cursorCaptureMode: "editable-overlay",
 	hideDesktopIcons: false,
@@ -79,6 +83,8 @@ export function RecStage({
 	onClose?: () => void;
 }) {
 	const t = useScopedT("editor");
+	const tLaunch = useScopedT("launch");
+	const nativeWindowsCapture = useNativeWindowsCaptureAvailable();
 	const [prefs, setPrefsState] = useState<RecordingPrefsState>(DEFAULT_PREFS);
 	// Bumped by every local change and every pushed snapshot, so the re-read after a
 	// failed write can tell that something newer has landed since.
@@ -478,6 +484,30 @@ export function RecStage({
 						</div>
 					</div>
 
+					{/* Cameras 2-4 are recorded beside camera 1 by the native Windows helper only, so the
+					    list waits for camera 1 and, without that helper, stays visible but disabled. */}
+					{prefs.camEnabled && camDevices.devices.length > 1 ? (
+						<div className={styles.recExtraCams}>
+							<AdditionalCamerasList
+								devices={camDevices.devices}
+								primaryDeviceId={prefs.camDeviceId ?? camDevices.selectedDeviceId}
+								selected={prefs.camAdditionalDevices}
+								onChange={(next) => updatePrefs({ camAdditionalDevices: next })}
+								disabled={!nativeWindowsCapture}
+								labels={{
+									title: tLaunch("webcam.additionalCameras"),
+									hint: tLaunch("webcam.additionalCamerasHint"),
+								}}
+								classes={{
+									title: styles.recExtraCamsTitle,
+									item: styles.recExtraCam,
+									itemActive: styles.recExtraCamOn,
+									hint: styles.recExtraCamsHint,
+								}}
+							/>
+						</div>
+					) : null}
+
 					{/* Without its native helper the browser records, and it always draws the system cursor
 					    into the video: there is nothing to switch, so neither this row nor Auto-zoom, which
 					    reads what the editable cursor records, is shown. Same rule as the HUD's button. */}
diff --git a/src/components/launch/AdditionalCamerasList.test.tsx b/src/components/launch/AdditionalCamerasList.test.tsx
new file mode 100644
index 000000000..061724417
--- /dev/null
+++ b/src/components/launch/AdditionalCamerasList.test.tsx
@@ -0,0 +1,137 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { useState } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { type AdditionalCameraChoice, AdditionalCamerasList } from "./AdditionalCamerasList";
+
+afterEach(cleanup);
+
+const labels = {
+	title: "Additional cameras",
+	hint: "Only with native Windows recording",
+};
+
+const device = (id: string) => ({ deviceId: id, label: `Camera ${id}`, groupId: id });
+const choice = (id: string): AdditionalCameraChoice => ({ id, name: `Camera ${id}` });
+
+describe("AdditionalCamerasList", () => {
+	it("the additional list never offers camera 1", () => {
+		render(
+			<AdditionalCamerasList
+				devices={[device("A"), device("B"), device("C")]}
+				primaryDeviceId="A"
+				selected={[]}
+				onChange={vi.fn()}
+				disabled={false}
+				labels={labels}
+			/>,
+		);
+
+		const items = screen.getAllByRole("menuitemcheckbox");
+		expect(items.map((item) => item.textContent)).toEqual(["Camera B", "Camera C"]);
+	});
+
+	it("keeps the order of selection", () => {
+		const onChange = vi.fn();
+		function Harness() {
+			const [selected, setSelected] = useState<AdditionalCameraChoice[]>([]);
+			return (
+				<AdditionalCamerasList
+					devices={[device("A"), device("B"), device("C")]}
+					primaryDeviceId="A"
+					selected={selected}
+					onChange={(next) => {
+						onChange(next);
+						setSelected(next);
+					}}
+					disabled={false}
+					labels={labels}
+				/>
+			);
+		}
+		render(<Harness />);
+
+		fireEvent.click(screen.getByRole("menuitemcheckbox", { name: "Camera C" }));
+		fireEvent.click(screen.getByRole("menuitemcheckbox", { name: "Camera B" }));
+
+		expect(onChange).toHaveBeenLastCalledWith([choice("C"), choice("B")]);
+		expect(screen.getByRole("menuitemcheckbox", { name: "Camera C" })).toHaveAttribute(
+			"aria-checked",
+			"true",
+		);
+	});
+
+	it("unchecks a camera that is already selected", () => {
+		const onChange = vi.fn();
+		render(
+			<AdditionalCamerasList
+				devices={[device("A"), device("B"), device("C")]}
+				primaryDeviceId="A"
+				selected={[choice("B"), choice("C")]}
+				onChange={onChange}
+				disabled={false}
+				labels={labels}
+			/>,
+		);
+
+		fireEvent.click(screen.getByRole("menuitemcheckbox", { name: "Camera B" }));
+
+		expect(onChange).toHaveBeenLastCalledWith([choice("C")]);
+	});
+
+	it("caps at three", () => {
+		const onChange = vi.fn();
+		render(
+			<AdditionalCamerasList
+				devices={[device("P"), device("B"), device("C"), device("D"), device("E")]}
+				primaryDeviceId="P"
+				selected={[choice("B"), choice("C"), choice("D")]}
+				onChange={onChange}
+				disabled={false}
+				labels={labels}
+			/>,
+		);
+
+		const fourth = screen.getByRole("menuitemcheckbox", { name: "Camera E" });
+		expect(fourth).toBeDisabled();
+		expect(screen.getByRole("menuitemcheckbox", { name: "Camera B" })).toBeEnabled();
+		fireEvent.click(fourth);
+		expect(onChange).not.toHaveBeenCalled();
+	});
+
+	it("is disabled with a hint without native Windows recording", () => {
+		const onChange = vi.fn();
+		render(
+			<AdditionalCamerasList
+				devices={[device("A"), device("B")]}
+				primaryDeviceId="A"
+				selected={[]}
+				onChange={onChange}
+				disabled
+				labels={labels}
+			/>,
+		);
+
+		const item = screen.getByRole("menuitemcheckbox", { name: "Camera B" });
+		expect(item).toBeDisabled();
+		expect(screen.getByText(labels.hint)).toBeInTheDocument();
+		fireEvent.click(item);
+		expect(onChange).not.toHaveBeenCalled();
+	});
+
+	it("shows no hint while it is usable", () => {
+		render(
+			<AdditionalCamerasList
+				devices={[device("A"), device("B")]}
+				primaryDeviceId="A"
+				selected={[]}
+				onChange={vi.fn()}
+				disabled={false}
+				labels={labels}
+			/>,
+		);
+
+		expect(screen.queryByText(labels.hint)).not.toBeInTheDocument();
+	});
+});
diff --git a/src/components/launch/AdditionalCamerasList.tsx b/src/components/launch/AdditionalCamerasList.tsx
new file mode 100644
index 000000000..4d8c83b6e
--- /dev/null
+++ b/src/components/launch/AdditionalCamerasList.tsx
@@ -0,0 +1,99 @@
+import { Check } from "lucide-react";
+import type { CameraDevice } from "../../hooks/useCameraDevices";
+import styles from "./LaunchWindow.module.css";
+
+/** Camera 1 plus this many more is the most a recording can hold. */
+export const MAX_ADDITIONAL_CAMERAS = 3;
+
+/** A picked extra camera, stored the way the recording prefs keep it. */
+export interface AdditionalCameraChoice {
+	id: string | null;
+	name: string;
+}
+
+export interface AdditionalCamerasLabels {
+	title: string;
+	/** Shown while the list is disabled: why it cannot be used here. */
+	hint: string;
+}
+
+/** Class names, so the editor's Rec stage can restyle the list without a second component. */
+export interface AdditionalCamerasClasses {
+	title?: string;
+	item?: string;
+	itemActive?: string;
+	hint?: string;
+}
+
+interface AdditionalCamerasListProps {
+	devices: CameraDevice[];
+	/** Camera 1: never offered again here. */
+	primaryDeviceId: string | undefined;
+	selected: AdditionalCameraChoice[];
+	onChange: (next: AdditionalCameraChoice[]) => void;
+	disabled: boolean;
+	labels: AdditionalCamerasLabels;
+	classes?: AdditionalCamerasClasses;
+}
+
+function isSameCamera(choice: AdditionalCameraChoice, device: CameraDevice): boolean {
+	return choice.id !== null ? choice.id === device.deviceId : choice.name === device.label;
+}
+
+/**
+ * Checkbox list for cameras 2-4. Selection keeps the order of the clicks, because that order is
+ * the order the cameras get their `-webcam-N` files in.
+ */
+export function AdditionalCamerasList({
+	devices,
+	primaryDeviceId,
+	selected,
+	onChange,
+	disabled,
+	labels,
+	classes,
+}: AdditionalCamerasListProps) {
+	const offered = devices.filter((device) => device.deviceId !== primaryDeviceId);
+	// A saved pick whose camera is unplugged is neither shown nor counted: it cannot be recorded.
+	const present = selected.filter((choice) =>
+		offered.some((device) => isSameCamera(choice, device)),
+	);
+	const full = present.length >= MAX_ADDITIONAL_CAMERAS;
+
+	const toggle = (device: CameraDevice) => {
+		if (disabled) return;
+		const isOn = present.some((choice) => isSameCamera(choice, device));
+		if (isOn) {
+			onChange(present.filter((choice) => !isSameCamera(choice, device)));
+		} else if (!full) {
+			onChange([...present, { id: device.deviceId, name: device.label }]);
+		}
+	};
+
+	return (
+		<>
+			<div className={classes?.title ?? styles.hudMenuSectionLabel}>{labels.title}</div>
+			{offered.map((device) => {
+				const isOn = present.some((choice) => isSameCamera(choice, device));
+				const blocked = disabled || (!isOn && full);
+				return (
+					<button
+						key={device.deviceId}
+						type="button"
+						role="menuitemcheckbox"
+						aria-checked={isOn}
+						disabled={blocked}
+						onClick={() => toggle(device)}
+						className={`${classes?.item ?? styles.languageMenuItem} ${
+							isOn ? (classes?.itemActive ?? styles.languageMenuItemActive) : ""
+						}`}
+					>
+						<span className="truncate">{device.label}</span>
+						{isOn ? <Check size={14} className="text-white/85" /> : null}
+					</button>
+				);
+			})}
+			{disabled ? <div className={classes?.hint ?? styles.hudModalHint}>{labels.hint}</div> : null}
+		</>
+	);
+}
diff --git a/src/components/launch/HudDeviceSettings.tsx b/src/components/launch/HudDeviceSettings.tsx
index 164b2f370..65c1a9931 100644
--- a/src/components/launch/HudDeviceSettings.tsx
+++ b/src/components/launch/HudDeviceSettings.tsx
@@ -6,6 +6,11 @@ import { useCameraPreviewStream } from "../../hooks/useCameraPreviewStream";
 import type { MicrophoneDevice } from "../../hooks/useMicrophoneDevices";
 import { WEBCAM_QUALITY_IDS, type WebcamQualityId } from "../../hooks/webcamCaptureTarget";
 import { Tooltip } from "../ui/tooltip";
+import {
+	type AdditionalCameraChoice,
+	type AdditionalCamerasLabels,
+	AdditionalCamerasList,
+} from "./AdditionalCamerasList";
 import styles from "./LaunchWindow.module.css";
 
 const LEVEL_SEGMENTS = 12;
@@ -31,6 +36,15 @@ export interface HudDeviceSettingsLabels {
 	cameraQualityOptions: Record<WebcamQualityId, string>;
 }
 
+/** Cameras 2-4. Left out while camera 1 is off, since they are only recorded beside it. */
+export interface HudAdditionalCameras {
+	selected: AdditionalCameraChoice[];
+	onChange: (next: AdditionalCameraChoice[]) => void;
+	/** No native Windows recording: the list stays visible, with its hint, but cannot be used. */
+	disabled: boolean;
+	labels: AdditionalCamerasLabels;
+}
+
 /** Segmented input-level bar, driven by the live analyser. */
 const LevelMeter = memo(function LevelMeter({ level }: { level: number }) {
 	const lit = Math.round((Math.min(100, Math.max(0, level)) / 100) * LEVEL_SEGMENTS);
@@ -101,6 +115,7 @@ export const HudDeviceSettings = memo(function HudDeviceSettings({
 	canCheckForUpdates,
 	checkingForUpdates,
 	cameraQuality,
+	additionalCameras,
 	onSelectCameraQuality,
 	onSelectMic,
 	onSelectCamera,
@@ -123,6 +138,7 @@ export const HudDeviceSettings = memo(function HudDeviceSettings({
 	canCheckForUpdates: boolean;
 	checkingForUpdates: boolean;
 	cameraQuality: WebcamQualityId;
+	additionalCameras?: HudAdditionalCameras;
 	onSelectCameraQuality: (quality: WebcamQualityId) => void;
 	onSelectMic: (device: MicrophoneDevice) => void;
 	onSelectCamera: (device: CameraDevice) => void;
@@ -223,6 +239,16 @@ export const HudDeviceSettings = memo(function HudDeviceSettings({
 					);
 				})
 			)}
+			{hasCamera && additionalCameras && cameraDevices.length > 1 ? (
+				<AdditionalCamerasList
+					devices={cameraDevices}
+					primaryDeviceId={activeCameraId}
+					selected={additionalCameras.selected}
+					onChange={additionalCameras.onChange}
+					disabled={additionalCameras.disabled}
+					labels={additionalCameras.labels}
+				/>
+			) : null}
 			{hasCamera ? (
 				<>
 					{/* Below the device list, because it qualifies the camera picked
diff --git a/src/components/launch/LaunchWindow.module.css b/src/components/launch/LaunchWindow.module.css
index 0f522b32e..59d700dbd 100644
--- a/src/components/launch/LaunchWindow.module.css
+++ b/src/components/launch/LaunchWindow.module.css
@@ -322,6 +322,16 @@
 	outline: none;
 }
 
+.languageMenuItem:disabled {
+	opacity: 0.45;
+	cursor: not-allowed;
+}
+
+.languageMenuItem:disabled:hover {
+	background: transparent;
+	color: rgba(255, 255, 255, 0.72);
+}
+
 .languageMenuItemActive {
 	background: rgba(16, 185, 129, 0.14);
 	color: #ffffff;
diff --git a/src/components/launch/LaunchWindow.tsx b/src/components/launch/LaunchWindow.tsx
index ca9dd076a..7aad7ccc4 100644
--- a/src/components/launch/LaunchWindow.tsx
+++ b/src/components/launch/LaunchWindow.tsx
@@ -12,11 +12,13 @@ import {
 	type MicrophoneDevice,
 	useMicrophoneDevices,
 } from "../../hooks/useMicrophoneDevices";
+import { useNativeWindowsCaptureAvailable } from "../../hooks/useNativeWindowsCaptureAvailable";
 import { usePortalOwnsSource } from "../../hooks/usePortalOwnsSource";
 import { useRememberedSourceName } from "../../hooks/useRememberedSourceName";
 import { useScreenRecorder } from "../../hooks/useScreenRecorder";
 import type { WebcamQualityId } from "../../hooks/webcamCaptureTarget";
 import { requestCameraAccess } from "../../lib/requestCameraAccess";
+import type { AdditionalCameraChoice } from "./AdditionalCamerasList";
 import {
 	HudCameraButton,
 	HudCursorButton,
@@ -119,6 +121,8 @@ export function LaunchWindow() {
 		setWebcamQuality,
 		webcamDeviceName,
 		setWebcamDeviceName,
+		webcamAdditionalDevices,
+		setWebcamAdditionalDevices,
 		cursorCaptureMode,
 		setCursorCaptureMode,
 		softwareEncoderFallbackNoticeVisible,
@@ -156,6 +160,7 @@ export function LaunchWindow() {
 	 */
 	const portalOwnsSource = usePortalOwnsSource();
 
+	const nativeWindowsCapture = useNativeWindowsCaptureAvailable();
 	const isVertical = trayLayout === "vertical";
 	const isPopoverOpen = isLanguageMenuOpen || isDeviceSettingsOpen;
 	const controlsLocked = recording || saving;
@@ -861,6 +866,7 @@ export function LaunchWindow() {
 			camDeviceId?: string;
 			camDeviceName?: string;
 			camQuality?: WebcamQualityId;
+			camAdditionalDevices?: AdditionalCameraChoice[];
 			micEnabled?: boolean;
 			micDeviceId?: string;
 			micDeviceName?: string;
@@ -942,6 +948,17 @@ export function LaunchWindow() {
 		[controlsLocked, persistRecordingPrefs, setWebcamQuality],
 	);
 
+	const handleChangeAdditionalCameras = useCallback(
+		(next: AdditionalCameraChoice[]) => {
+			// Same guard as the quality: a panel left open mid-take must not rewrite what the take
+			// was started with.
+			if (controlsLocked) return;
+			setWebcamAdditionalDevices(next);
+			persistRecordingPrefs({ camAdditionalDevices: next });
+		},
+		[controlsLocked, persistRecordingPrefs, setWebcamAdditionalDevices],
+	);
+
 	const toggleDeviceSettings = useCallback(() => {
 		if (controlsLocked) return;
 		setIsLanguageMenuOpen(false);
@@ -1095,6 +1112,28 @@ export function LaunchWindow() {
 		[t, tCommon],
 	);
 
+	const additionalCameras = useMemo(
+		() =>
+			webcamEnabled
+				? {
+						selected: webcamAdditionalDevices,
+						onChange: handleChangeAdditionalCameras,
+						disabled: !nativeWindowsCapture,
+						labels: {
+							title: t("webcam.additionalCameras"),
+							hint: t("webcam.additionalCamerasHint"),
+						},
+					}
+				: undefined,
+		[
+			handleChangeAdditionalCameras,
+			nativeWindowsCapture,
+			t,
+			webcamAdditionalDevices,
+			webcamEnabled,
+		],
+	);
+
 	const versionLabel = appInfo ? t("deviceSettings.version", { version: appInfo.version }) : null;
 
 	const hasNotices = Boolean(systemLocaleSuggestion) || softwareEncoderFallbackNoticeVisible;
@@ -1321,6 +1360,7 @@ export function LaunchWindow() {
 								canCheckForUpdates={(appInfo?.canCheckForUpdates ?? false) && !recording}
 								checkingForUpdates={isCheckingForUpdates}
 								cameraQuality={webcamQuality}
+								additionalCameras={additionalCameras}
 								onSelectCameraQuality={handleSelectCameraQuality}
 								onSelectMic={handleSelectMicDevice}
 								onSelectCamera={handleSelectCameraDevice}
diff --git a/src/hooks/useNativeWindowsCaptureAvailable.ts b/src/hooks/useNativeWindowsCaptureAvailable.ts
new file mode 100644
index 000000000..1a6806c39
--- /dev/null
+++ b/src/hooks/useNativeWindowsCaptureAvailable.ts
@@ -0,0 +1,27 @@
+import { useEffect, useState } from "react";
+import { getPlatform } from "@/utils/platformUtils";
+
+/**
+ * Whether this machine records through the native Windows helper, the only path that can hold
+ * more than one camera. `false` until the helper has answered, and for a failed probe: an option
+ * that cannot work is shown disabled rather than offered.
+ */
+export function useNativeWindowsCaptureAvailable(): boolean {
+	const [available, setAvailable] = useState(false);
+
+	useEffect(() => {
+		const probe = window.electronAPI?.isNativeWindowsCaptureAvailable;
+		if (getPlatform() !== "win32" || !probe) return;
+		let cancelled = false;
+		void probe()
+			.then((result) => {
+				if (!cancelled) setAvailable(result.success && result.available);
+			})
+			.catch(() => {});
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	return available;
+}
diff --git a/src/hooks/useScreenRecorder.noCamera.test.tsx b/src/hooks/useScreenRecorder.noCamera.test.tsx
index cd75f16b8..b2ba793d6 100644
--- a/src/hooks/useScreenRecorder.noCamera.test.tsx
+++ b/src/hooks/useScreenRecorder.noCamera.test.tsx
@@ -30,6 +30,7 @@ function prefs(camEnabled: boolean): RecordingPrefs {
 		camEnabled,
 		camDeviceId: null,
 		camDeviceName: null,
+		camAdditionalDevices: [],
 		camQuality: "2160p",
 		systemAudioEnabled: false,
 		cursorCaptureMode: "editable-overlay",
diff --git a/src/hooks/useScreenRecorder.prefsRace.test.tsx b/src/hooks/useScreenRecorder.prefsRace.test.tsx
index ae84c2cd7..83d2197dd 100644
--- a/src/hooks/useScreenRecorder.prefsRace.test.tsx
+++ b/src/hooks/useScreenRecorder.prefsRace.test.tsx
@@ -25,6 +25,7 @@ function prefs(micEnabled: boolean): RecordingPrefs {
 		camEnabled: false,
 		camDeviceId: null,
 		camDeviceName: null,
+		camAdditionalDevices: [],
 		camQuality: "2160p",
 		systemAudioEnabled: false,
 		cursorCaptureMode: "editable-overlay",
diff --git a/src/hooks/useScreenRecorder.ts b/src/hooks/useScreenRecorder.ts
index 915fcf959..a5a88cdfa 100644
--- a/src/hooks/useScreenRecorder.ts
+++ b/src/hooks/useScreenRecorder.ts
@@ -2,6 +2,7 @@ import { fixWebmDuration } from "@fix-webm-duration/fix";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { toast } from "sonner";
 import { useScopedT } from "@/contexts/I18nContext";
+import { type AdditionalCameraPick, resolveAdditionalWebcams } from "@/lib/additionalWebcams";
 import { mixAudioTracks, nativeMicrophoneGain } from "@/lib/audioMix";
 import {
 	type NativeLinuxRecordingRequest,
@@ -32,6 +33,16 @@ import {
 } from "./webcamCaptureTarget";
 import { webcamDeviceIdentityFrom } from "./webcamDeviceIdentity";
 
+/** The cameras the system lists right now; empty when it cannot say. */
+async function listPresentCameras(): Promise<Array<{ deviceId: string; label: string }>> {
+	try {
+		const devices = await navigator.mediaDevices.enumerateDevices();
+		return devices.filter((device) => device.kind === "videoinput");
+	} catch {
+		return [];
+	}
+}
+
 const TARGET_FRAME_RATE = 60;
 const MIN_FRAME_RATE = 30;
 const TARGET_WIDTH = 3840;
@@ -110,6 +121,9 @@ type UseScreenRecorderReturn = {
 	setWebcamQuality: (quality: WebcamQualityId) => void;
 	webcamDeviceName: string | undefined;
 	setWebcamDeviceName: (deviceName: string | undefined) => void;
+	/** Cameras 2-4, in pick order. Recorded only by the native Windows path. */
+	webcamAdditionalDevices: AdditionalCameraPick[];
+	setWebcamAdditionalDevices: (devices: AdditionalCameraPick[]) => void;
 	systemAudioEnabled: boolean;
 	setSystemAudioEnabled: (enabled: boolean) => void;
 	webcamEnabled: boolean;
@@ -268,6 +282,11 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 	useEffect(() => {
 		tRef.current = t;
 	}, [t]);
+	// Same reason as `tRef`: read by `finalizeNativeWindowsRecording`.
+	const tLaunchRef = useRef(tLaunch);
+	useEffect(() => {
+		tLaunchRef.current = tLaunch;
+	}, [tLaunch]);
 	useEffect(() => {
 		return window.electronAPI?.onNativeMacSystemAudioUnavailable?.(() => {
 			toast.warning(tRef.current("recording.systemAudioUnavailable"));
@@ -283,6 +302,9 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 	const [webcamDeviceId, setWebcamDeviceId] = useState<string | undefined>(undefined);
 	const [webcamQuality, setWebcamQuality] = useState<WebcamQualityId>(DEFAULT_WEBCAM_QUALITY);
 	const [webcamDeviceName, setWebcamDeviceName] = useState<string | undefined>(undefined);
+	const [webcamAdditionalDevices, setWebcamAdditionalDevices] = useState<AdditionalCameraPick[]>(
+		[],
+	);
 	const [systemAudioEnabled, setSystemAudioEnabled] = useState(false);
 	const [webcamEnabled, setWebcamEnabledState] = useState(false);
 	const [cursorCaptureMode, setCursorCaptureMode] = useState<CursorCaptureMode>("editable-overlay");
@@ -307,6 +329,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 			camDeviceId?: string | null;
 			camDeviceName?: string | null;
 			camQuality?: WebcamQualityId | null;
+			camAdditionalDevices?: AdditionalCameraPick[] | null;
 			systemAudioEnabled: boolean;
 			cursorCaptureMode: CursorCaptureMode;
 		}) => {
@@ -325,6 +348,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 				setWebcamDeviceName(prefs.camDeviceName ?? undefined);
 			}
 			setWebcamQuality(webcamQualityFrom(prefs.camQuality));
+			setWebcamAdditionalDevices(prefs.camAdditionalDevices ?? []);
 			setSystemAudioEnabled(prefs.systemAudioEnabled);
 			setCursorCaptureMode(prefs.cursorCaptureMode);
 			setRecordingPrefsLoaded(true);
@@ -782,6 +806,13 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 			if (result.webcamDropped) {
 				toast.error(tRef.current("recording.cameraCaptureUnavailable"));
 			}
+			if (result.droppedWebcams?.length) {
+				toast.error(
+					tLaunchRef.current("webcam.camerasNotRecorded", {
+						names: result.droppedWebcams.join(", "),
+					}),
+				);
+			}
 			if (result.session) {
 				await window.electronAPI.setCurrentRecordingSession(result.session);
 			} else if (result.path) {
@@ -1258,6 +1289,13 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 				// MediaRecorder against the helper's own process-spawn/WGC-init latency.
 				stopWebcamPreviewStream();
 			}
+			const additionalWebcams = webcamEnabled
+				? resolveAdditionalWebcams(
+						webcamAdditionalDevices,
+						await listPresentCameras(),
+						webcamIdentity.deviceId,
+					)
+				: [];
 			const request: NativeWindowsRecordingRequest = {
 				recordingId: activeRecordingId,
 				preferSoftwareEncoder: loadUserPreferences().preferSoftwareEncoder,
@@ -1292,6 +1330,8 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 					height: webcamPresetFor(webcamQuality).height,
 					fps: WEBCAM_TARGET_FRAME_RATE,
 				},
+				// Cameras 2-4 ride along only with camera 1: with it off the helper gets no extras.
+				...(additionalWebcams.length > 0 ? { additionalWebcams } : {}),
 				cursor: {
 					mode: cursorCaptureMode,
 				},
@@ -1308,6 +1348,11 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 			if (result.webcamUnavailable) {
 				toast.error(t("recording.cameraCaptureUnavailable"));
 			}
+			if (result.unavailableWebcams?.length) {
+				toast.error(
+					tLaunch("webcam.camerasNotRecorded", { names: result.unavailableWebcams.join(", ") }),
+				);
+			}
 			if (result.microphoneDefaulted) {
 				toast.error(t("recording.microphoneDefaulted"));
 			}
@@ -2454,6 +2499,8 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 		setWebcamQuality,
 		webcamDeviceName,
 		setWebcamDeviceName,
+		webcamAdditionalDevices,
+		setWebcamAdditionalDevices,
 		systemAudioEnabled,
 		setSystemAudioEnabled,
 		webcamEnabled,
diff --git a/src/i18n/locales/ar/launch.json b/src/i18n/locales/ar/launch.json
index ef613d15d..858d9d8e9 100644
--- a/src/i18n/locales/ar/launch.json
+++ b/src/i18n/locales/ar/launch.json
@@ -48,6 +48,9 @@
 		"camera": "الكاميرا",
 		"cameraDevice": "جهاز الكاميرا",
 		"quality": "جودة الكاميرا",
+		"additionalCameras": "كاميرات إضافية",
+		"additionalCamerasHint": "فقط مع التسجيل الأصلي في Windows",
+		"camerasNotRecorded": "لم يتم تسجيلها: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/cs/launch.json b/src/i18n/locales/cs/launch.json
index d9912da51..d79eb409b 100644
--- a/src/i18n/locales/cs/launch.json
+++ b/src/i18n/locales/cs/launch.json
@@ -48,6 +48,9 @@
 		"camera": "Kamera",
 		"cameraDevice": "Zařízení kamery",
 		"quality": "Kvalita kamery",
+		"additionalCameras": "Další kamery",
+		"additionalCamerasHint": "Pouze s nativním nahráváním ve Windows",
+		"camerasNotRecorded": "Nenahráno: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/de/launch.json b/src/i18n/locales/de/launch.json
index b4dab82a9..2ba2310d7 100644
--- a/src/i18n/locales/de/launch.json
+++ b/src/i18n/locales/de/launch.json
@@ -48,6 +48,9 @@
 		"camera": "Kamera",
 		"cameraDevice": "Kameragerät",
 		"quality": "Kameraqualität",
+		"additionalCameras": "Weitere Kameras",
+		"additionalCamerasHint": "Nur bei nativer Windows-Aufnahme",
+		"camerasNotRecorded": "Nicht aufgenommen: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/en/launch.json b/src/i18n/locales/en/launch.json
index 97263f184..2489623aa 100644
--- a/src/i18n/locales/en/launch.json
+++ b/src/i18n/locales/en/launch.json
@@ -48,6 +48,9 @@
 		"camera": "Camera",
 		"cameraDevice": "Camera device",
 		"quality": "Camera quality",
+		"additionalCameras": "Additional cameras",
+		"additionalCamerasHint": "Only with native Windows recording",
+		"camerasNotRecorded": "Not recorded: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/es/launch.json b/src/i18n/locales/es/launch.json
index 3114921ec..565d4a852 100644
--- a/src/i18n/locales/es/launch.json
+++ b/src/i18n/locales/es/launch.json
@@ -48,6 +48,9 @@
 		"camera": "Cámara",
 		"cameraDevice": "Dispositivo de cámara",
 		"quality": "Calidad de la cámara",
+		"additionalCameras": "Cámaras adicionales",
+		"additionalCamerasHint": "Solo con la grabación nativa de Windows",
+		"camerasNotRecorded": "No grabadas: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/fr/launch.json b/src/i18n/locales/fr/launch.json
index c956fb37a..0cc342866 100644
--- a/src/i18n/locales/fr/launch.json
+++ b/src/i18n/locales/fr/launch.json
@@ -48,6 +48,9 @@
 		"camera": "Caméra",
 		"cameraDevice": "Périphérique caméra",
 		"quality": "Qualité de la caméra",
+		"additionalCameras": "Caméras supplémentaires",
+		"additionalCamerasHint": "Uniquement avec l'enregistrement natif sous Windows",
+		"camerasNotRecorded": "Non enregistrées : {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/it/launch.json b/src/i18n/locales/it/launch.json
index 9897b92eb..2290d693a 100644
--- a/src/i18n/locales/it/launch.json
+++ b/src/i18n/locales/it/launch.json
@@ -48,6 +48,9 @@
 		"camera": "Fotocamera",
 		"cameraDevice": "Dispositivo fotocamera",
 		"quality": "Qualità della fotocamera",
+		"additionalCameras": "Fotocamere aggiuntive",
+		"additionalCamerasHint": "Solo con la registrazione nativa di Windows",
+		"camerasNotRecorded": "Non registrate: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/ja-JP/launch.json b/src/i18n/locales/ja-JP/launch.json
index 9f2323eec..4d7fcf3ce 100644
--- a/src/i18n/locales/ja-JP/launch.json
+++ b/src/i18n/locales/ja-JP/launch.json
@@ -48,6 +48,9 @@
 		"camera": "カメラ",
 		"cameraDevice": "カメラデバイス",
 		"quality": "カメラの画質",
+		"additionalCameras": "追加のカメラ",
+		"additionalCamerasHint": "Windows のネイティブ録画でのみ使用できます",
+		"camerasNotRecorded": "録画されませんでした: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/ko-KR/launch.json b/src/i18n/locales/ko-KR/launch.json
index 5ce2b8e72..641fb53d8 100644
--- a/src/i18n/locales/ko-KR/launch.json
+++ b/src/i18n/locales/ko-KR/launch.json
@@ -48,6 +48,9 @@
 		"camera": "카메라",
 		"cameraDevice": "카메라 장치",
 		"quality": "카메라 화질",
+		"additionalCameras": "추가 카메라",
+		"additionalCamerasHint": "Windows 기본 녹화에서만 사용할 수 있습니다",
+		"camerasNotRecorded": "녹화되지 않음: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/pt-BR/launch.json b/src/i18n/locales/pt-BR/launch.json
index 886615088..276d494e0 100644
--- a/src/i18n/locales/pt-BR/launch.json
+++ b/src/i18n/locales/pt-BR/launch.json
@@ -48,6 +48,9 @@
 		"camera": "Câmera",
 		"cameraDevice": "Dispositivo de câmera",
 		"quality": "Qualidade da câmera",
+		"additionalCameras": "Câmeras adicionais",
+		"additionalCamerasHint": "Somente com a gravação nativa do Windows",
+		"camerasNotRecorded": "Não gravadas: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/ru/launch.json b/src/i18n/locales/ru/launch.json
index cdc103c0b..1d99fd9b5 100644
--- a/src/i18n/locales/ru/launch.json
+++ b/src/i18n/locales/ru/launch.json
@@ -48,6 +48,9 @@
 		"camera": "Камера",
 		"cameraDevice": "Устройство камеры",
 		"quality": "Качество камеры",
+		"additionalCameras": "Дополнительные камеры",
+		"additionalCamerasHint": "Только при встроенной записи в Windows",
+		"camerasNotRecorded": "Не записаны: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/tr/launch.json b/src/i18n/locales/tr/launch.json
index 530157dd2..22c00b419 100644
--- a/src/i18n/locales/tr/launch.json
+++ b/src/i18n/locales/tr/launch.json
@@ -48,6 +48,9 @@
 		"camera": "Kamera",
 		"cameraDevice": "Kamera cihazı",
 		"quality": "Kamera kalitesi",
+		"additionalCameras": "Ek kameralar",
+		"additionalCamerasHint": "Yalnızca yerel Windows kaydıyla",
+		"camerasNotRecorded": "Kaydedilmedi: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/vi/launch.json b/src/i18n/locales/vi/launch.json
index 53f452e27..0416dce15 100644
--- a/src/i18n/locales/vi/launch.json
+++ b/src/i18n/locales/vi/launch.json
@@ -48,6 +48,9 @@
 		"camera": "Máy ảnh",
 		"cameraDevice": "Thiết bị máy ảnh",
 		"quality": "Chất lượng camera",
+		"additionalCameras": "Camera bổ sung",
+		"additionalCamerasHint": "Chỉ với tính năng quay gốc của Windows",
+		"camerasNotRecorded": "Không được ghi: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/zh-CN/launch.json b/src/i18n/locales/zh-CN/launch.json
index 7a61e466e..03cb0f418 100644
--- a/src/i18n/locales/zh-CN/launch.json
+++ b/src/i18n/locales/zh-CN/launch.json
@@ -48,6 +48,9 @@
 		"camera": "摄像头",
 		"cameraDevice": "摄像头设备",
 		"quality": "摄像头画质",
+		"additionalCameras": "附加摄像头",
+		"additionalCamerasHint": "仅支持 Windows 原生录制",
+		"camerasNotRecorded": "未录制：{{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/zh-TW/launch.json b/src/i18n/locales/zh-TW/launch.json
index 2e460592e..97bb58696 100644
--- a/src/i18n/locales/zh-TW/launch.json
+++ b/src/i18n/locales/zh-TW/launch.json
@@ -48,6 +48,9 @@
 		"camera": "攝影機",
 		"cameraDevice": "攝影機裝置",
 		"quality": "攝影機畫質",
+		"additionalCameras": "額外攝影機",
+		"additionalCamerasHint": "僅限 Windows 原生錄影",
+		"camerasNotRecorded": "未錄製：{{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/lib/additionalWebcams.test.ts b/src/lib/additionalWebcams.test.ts
new file mode 100644
index 000000000..f3889a36f
--- /dev/null
+++ b/src/lib/additionalWebcams.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { resolveAdditionalWebcams } from "./additionalWebcams";
+
+const present = [
+	{ deviceId: "a", label: "Cam A" },
+	{ deviceId: "b", label: "Cam B" },
+	{ deviceId: "c", label: "Cam C" },
+	{ deviceId: "d", label: "Cam D" },
+	{ deviceId: "e", label: "Cam E" },
+];
+
+describe("resolveAdditionalWebcams", () => {
+	it("keeps the order of the picks and reports the current id and label", () => {
+		expect(
+			resolveAdditionalWebcams(
+				[
+					{ id: "c", name: "Cam C" },
+					{ id: "b", name: "Cam B" },
+				],
+				present,
+				"a",
+			),
+		).toEqual([
+			{ deviceId: "c", deviceName: "Cam C" },
+			{ deviceId: "b", deviceName: "Cam B" },
+		]);
+	});
+
+	it("drops cameras that are no longer present and falls back to the name when the id changed", () => {
+		expect(
+			resolveAdditionalWebcams(
+				[
+					{ id: "gone", name: "Unplugged" },
+					{ id: "old-id", name: "Cam B" },
+				],
+				present,
+				"a",
+			),
+		).toEqual([{ deviceId: "b", deviceName: "Cam B" }]);
+	});
+
+	it("never repeats camera 1 or a camera picked twice", () => {
+		expect(
+			resolveAdditionalWebcams(
+				[
+					{ id: "a", name: "Cam A" },
+					{ id: "b", name: "Cam B" },
+					{ id: null, name: "Cam B" },
+				],
+				present,
+				"a",
+			),
+		).toEqual([{ deviceId: "b", deviceName: "Cam B" }]);
+	});
+
+	it("caps at three", () => {
+		const picks = ["b", "c", "d", "e"].map((id) => ({ id, name: `Cam ${id.toUpperCase()}` }));
+		expect(resolveAdditionalWebcams(picks, present, "a")).toHaveLength(3);
+	});
+});
diff --git a/src/lib/additionalWebcams.ts b/src/lib/additionalWebcams.ts
new file mode 100644
index 000000000..c386821f1
--- /dev/null
+++ b/src/lib/additionalWebcams.ts
@@ -0,0 +1,36 @@
+export interface AdditionalCameraPick {
+	id: string | null;
+	name: string;
+}
+
+export interface PresentCamera {
+	deviceId: string;
+	label: string;
+}
+
+const MAX_ADDITIONAL_WEBCAMS = 3;
+
+/**
+ * The cameras 2-4 of a native Windows request: the saved picks that are still plugged in, under
+ * the id and label the system reports now (an id can change between sessions, the pick is
+ * matched by id first and by name second). Camera 1, repeats and anything past the cap are left
+ * out; the order of the picks is kept.
+ */
+export function resolveAdditionalWebcams(
+	picks: AdditionalCameraPick[],
+	present: PresentCamera[],
+	primaryDeviceId: string | undefined,
+): Array<{ deviceId: string; deviceName: string }> {
+	const resolved: Array<{ deviceId: string; deviceName: string }> = [];
+	for (const pick of picks) {
+		if (resolved.length >= MAX_ADDITIONAL_WEBCAMS) break;
+		const device =
+			(pick.id !== null
+				? present.find((candidate) => candidate.deviceId === pick.id)
+				: undefined) ?? present.find((candidate) => candidate.label === pick.name);
+		if (!device || device.deviceId === primaryDeviceId) continue;
+		if (resolved.some((entry) => entry.deviceId === device.deviceId)) continue;
+		resolved.push({ deviceId: device.deviceId, deviceName: device.label });
+	}
+	return resolved;
+}

From 66bb3b51d36c3d8ab628e08b4c3c280de58aceb8 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 12:43:20 +0200
Subject: [PATCH 11/22] fix(hud): note why the capture probe failed

---
 src/hooks/useNativeWindowsCaptureAvailable.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/hooks/useNativeWindowsCaptureAvailable.ts b/src/hooks/useNativeWindowsCaptureAvailable.ts
index 1a6806c39..c6a0faf57 100644
--- a/src/hooks/useNativeWindowsCaptureAvailable.ts
+++ b/src/hooks/useNativeWindowsCaptureAvailable.ts
@@ -17,7 +17,9 @@ export function useNativeWindowsCaptureAvailable(): boolean {
 			.then((result) => {
 				if (!cancelled) setAvailable(result.success && result.available);
 			})
-			.catch(() => {});
+			.catch((error) => {
+				console.warn("Could not probe native Windows capture:", error);
+			});
 		return () => {
 			cancelled = true;
 		};

From a8fea4b2b65f1feb41d14710ccac3d48057723ec Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 12:50:00 +0200
Subject: [PATCH 12/22] docs(e2e): several cameras on Windows

---
 .../testing/manual-e2e-checklist.md                 | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.md
index 60095b9e2..ec4a4fd09 100644
--- a/technical-documentation/testing/manual-e2e-checklist.md
+++ b/technical-documentation/testing/manual-e2e-checklist.md
@@ -219,6 +219,18 @@ The helper waits up to 3 s for the camera's first visible frame before starting
 
 - [ ] Take two recordings of one scene, holding a page of small printed text at arm's length: one at 640x480, from a camera that only offers 640x480 or from a release older than #875, and one at 1080p or 4K. Add a Full Camera segment over the same moment in each project, export MP4 at 1080p, extract a frame with `ffmpeg -ss <t> -i <export> -frames:v 1 frame.png`, and view both at 100%. The 1080p take resolves the text and the 640x480 take, upscaled about threefold, does not. With neither reference at hand, log `skipped: no 640x480 reference`.
 
+### Several cameras (Windows)
+
+Up to four cameras record into one take on the native Windows path: camera 1 as today, up to three more picked under the HUD's *Additional cameras*. macOS, Linux and the browser recorder stay single-camera, and the section shows disabled with a hint there. Each extra camera is its own file beside the recording: `-webcam-2.mp4`, `-webcam-3.mp4`, `-webcam-4.mp4`.
+
+- [ ] Several cameras (Windows). Pick a second camera under *Additional cameras*, record about 10 s and clap in front of both cameras. Both camera files exist next to the recording (`-webcam.mp4`, `-webcam-2.mp4`) and both play. The clap lands at the same time in both and against the screen. The editor shows camera 1 as before. After saving and reopening, the project still lists both cameras.
+- [ ] Order of the runs: start with two cameras of different names (Logitech Brio plus C920), then two identical Brios. Record at 1080p first, and at 4K afterwards as a load test: two 4K cameras on one USB controller may lack the bandwidth, so a camera that drops out there is a finding about the controller first and the app second. Log the controller layout next to the result.
+- [ ] With two identical Brios, which physical Brio becomes camera 1 follows Windows' enumeration order, not the HUD choice or its preview. A swap against the preview is a known limitation, not a defect. Wave a hand into one camera at a time to tell the files apart, and note which is which.
+- [ ] Read the helper output (`Save diagnostics`, or `(Get-Content diag.json -Raw | ConvertFrom-Json).helperOutput.windows -split "`n" | Select-String "webcam"`). Camera 2's `Native webcam candidate` lines list the second Brio, and neither the IR or any other interface of the first Brio nor a candidate marked `already recording in this take`. Each camera prints its own `webcam-format` event with its `index`, and `recording-stopped` carries both paths in `webcamPaths`.
+- [ ] A camera that cannot be opened or records nothing is named in a "Not recorded: …" notice after the take, and the take is kept with the cameras that worked. Provoke it by unplugging the second camera, or holding it open in another app, just before *Start recording*, and check the helper output for `{"event":"warning","code":"webcam-unavailable","index":1,…}`. Camera 1 and the screen are unaffected.
+- [ ] With the first camera turned off in the HUD, record again and confirm no additional camera is recorded (additional cameras follow camera 1).
+- [ ] Probe every file: `ffprobe -show_entries format=duration` of each camera file is within 0.2 s of the screen file's.
+
 ## Editor opens and loads the project
 
 - [ ] Confirm the editor opens after a successful stop, in Edit mode, with the expected project title and asset and a "Recording added to a new project" toast.
@@ -854,3 +866,4 @@ On macOS 15.2+ it opens at launch, until it has been closed once, while one of i
 | 2026-10-03 | installed `v2.0.0-rc.13` (NSIS from the release, sha512 matched `latest.yml`), installed over rc.12 for all users, About reports `2.0.0-rc.13` | Windows 11 Home 26200, 1920×1080 @ 125 %, AMD Radeon iGPU, built-in USB2.0 HD UVC WebCam | Partial — 1 defect | **Scoped to the app changes between rc.8, the last computer-use pass, and rc.13**; the export path itself is covered by the rc.13 row above. Real OS mouse and keyboard input throughout; computer-use screenshots came back uniformly grey again, so the app was observed through `PrintWindow` on its own windows and DOM reads over CDP. **Defect: the webcam shows its first frame when a clip is entered past the webcam's last frame from another clip.** Two clips of one take (screen video 50.98 s, webcam 51.24 s, audio and clip 51.31 s): scrubbing from clip 2 to 51.2 s in clip 1 shows the screen's last frame, as 227b9b84 intends, but the webcam's frame 0 (2 of 2; ground truth from ffmpeg: an empty chair from 18.7 s to the end). Scrubbing to the same point from inside clip 1, or to 51.0 s from clip 2, shows the right webcam frame. Cause: `open_and_seek_clip` and `seek_pair` in `crates/compositor/src/live.rs` seek the webcam with `seek_to` and fall back to `seek_to(0.0)`, where `present_frame` uses `seek_to_or_last`; unchanged on `main`. Paused scrub only, in a ~70 ms window at the end of each clip. **Passed:** #961: one take with the countdown overlay, Record mode, editor work and an export, then closing the editor left 0 processes. #966: after rebinding *Add zoom* to Q and *Add audio* to J, the empty-lane hints read "Appuyez sur Q pour ajouter un zoom" and "Appuyez sur J pour ajouter un audio, V pour enregistrer une voix off", and Q adds a zoom. Wordmark menu in French: every row 31 px (one line), menu 261 px wide, "2.0.0-rc.13" in one piece. Preview: playback from 0:12 to 0:45.8 across a trim (0:15.0 → 0:18.5) and a 1.5× region with no canvas stall over 150 ms, 32–50 picture changes a second, wall time matching the edit; stops at 0:51.3 on the screen's and the webcam's last frames. #960 (#964): A → B → A with the playhead at 0:06, the preview is pixel-identical to before (mean difference 0, against 77.9 for project B). Background image → gradient → colour followed in the preview. #968: a media file whose read the OS refused (`icacls` deny on the test file) — *Regenerate* shows the translated "Impossible de lire l'audio de ce média…" hint inline and in the "Échec de la transcription" toast, without the IPC wrapper; the main process logs `MediaUnreadableError … Permission denied`. MP4 export from the GUI, 1752×1080 30 fps: 2930 frames, video 97.633 s against audio 97.666 s, zoom, background, webcam and cursor present in extracted frames, −18.3 LUFS. **Also seen:** the green "Aucune parole détectée" chip from the earlier successful run stays next to the unreadable hint; each clip of the take still carries 0.32 s of audio past its video (what is left of #942), and the export ends each clip at its video (97.63 s, against 98.22 s from the clip lengths the timeline shows). **Not run:** the HUD with no camera (#967; a camera is attached), the macOS HUD fix (c2a8559e), tray, microphone and system-audio content, GIF, macOS and Linux. |
 | 2026-10-03 | installed `v2.0.0-rc.13`, CI-built DMG `Openscreen-macOS-Apple-Silicon-2.0.0-rc.13.dmg` from the GitHub Release (tag `018d22ab`), installed over rc.12, `spctl`: accepted, Notarized Developer ID (M4LK7C6S84), About reports `2.0.0-rc.13` | macOS 26.5 (25F71), Mac mini M1, 3840×2160, no camera, no microphone | Partial, no defect | **Scoped to the app changes between rc.8 and rc.13, on macOS**: the Windows row above covers the same diff on Windows and leaves out #967, c2a8559e and macOS, which this row takes. Real OS mouse and keyboard input through computer-use (screenshots worked on this Mac); Apple's picker is owned by Control Centre and cannot be granted, so the operator clicked *Share Entire Screen* for each take. **c2a8559e (HUD kept out of takes after the editor round trip):** take 1 picked from the HUD's record button (`excludedWindowIds: [582]`), stop, editor, Record mode showed the source as *Choose what to record*, *Start recording* reopened Apple's picker instead of reusing the pick, take 2 recorded with `excludedWindowIds: [639]`; frames extracted from both files (28:26 and 13:04) show no HUD where it sat. **#967 (no camera on this Mac):** with `camEnabled: true` and no camera identity in `recording-settings.json`, launch rewrote it to `false` and the HUD showed the camera off; same with a stale identity (`camDeviceId` + `camDeviceName` of an unplugged camera); clicking the toggle keeps it off with the "Camera access is blocked" toast; Record mode reads *Camera Off*. **#961:** closing the editor after take 2 (countdown overlay, Record mode handover) left 0 processes; so did closing it after a long editor session (eight project opens through the native panel, transcriptions, Media mode, an export, the export dialog's save panel cancelled). **#966:** with *Add zoom* bound to X in `shortcuts.json`, the empty zoom lane reads "Press X to add zoom", and "Appuyez sur X pour ajouter un zoom" / "Drücke X, …" in French and German. **Wordmark menu (3bee2d25):** French and German, every row on one line, "2.0.0-rc.13" in one piece. **#960 (b834416c):** project A with captions → project B → A again: captions show at once at 0:06.4, 0:10.2 and 1:05.2 without touching *Show captions* (0:05.3 shows none, a 4.77 to 5.57 s silence in the saved words). **Preview:** playback from 0:12 to the end across four transcript silence cuts, a 2× and a 16× region: picture and captions follow, the readout advances with the edit, stops at 1:06.2; no stall seen, 8 `[pipeline] décodage` opens for one seek and four cuts (consistent with a preload per cut; not compared with rc.12). **227b9b84 / 83fbcecc:** a two-clip project whose first clip is a file with 8 s of video and 10 s of audio (no camera): seeking from clip 2 to 0:09.5 shows clip 1's last frame, the same as 0:07.7, no stderr. A video-only file plays with its picture (e73097c8). **#968:** project whose first asset is `chmod 000`: `MediaUnreadableError … Permission denied` in the main log, clip 2 still transcribed, the asset card shows "Transcription failed" and "Couldn't read this media's audio. Make sure OpenScreen can access the folder it's in, then regenerate." without the IPC wrapper; after `chmod 644`, *Regenerate* runs again (not persisted as no-audio). **Metal compositor (8caaa20d, dd5e914b, 0624c148, 2fb994eb):** laptop frame, 3D cursor, click impact, image background blurred 53 %, Aurora, captions; MP4 1080p60 export of 3374 frames, video and audio 56.23 s against 56.21 s computed (66.154 s minus 5.09 s of cuts minus the 2× and 16× gains), full decode clean; extracted frames show the laptop with its shadow, the blurred background, the 3D cursor with its shadow, rounded screen corners and captions. During playback the preview followed image → image, blur 52 → 1 %, image → colour and back. **Also seen:** the playhead keeps its time when another project is opened (0:41.0 from A shown in B and C). With a hand-written `camDeviceName` and a null `camDeviceId`, the HUD keeps the camera on and the file at `true` (`useCameraHudSync` compares the empty selection with the empty id and returns early); the app always writes both together, so this state is artificial. Out of scope: a 10 s extract with speech under loud video sound transcribes as no speech in Auto (detected `en`, p 0.35) and as "*Musique*" in French. **Not run:** webcam and microphone (none on this Mac), so the Windows row's webcam-past-the-end defect cannot be checked here; click impact not confirmed (the fixture's cursor sidecar has no clicks, and none was identified around the nine clicks of take 2 at preview scale); Aurora motion on a plain colour; the 4× preview lag of the rc.12 row (not re-measured: this pass played 2× and 16× regions without timing the lag); `Esc`; tray; GIF; A/B against rc.12; Gatekeeper (the DMG came through `gh`, no quarantine flag); Intel. |
 | 2026-10-03 | installed `v2.0.0-rc.15` (build run 37124242835, tag `ccd8b449`, NSIS sha512 matched `latest.yml`), installed over rc.12 for all users, About reports `2.0.0-rc.15` (`win32 x64 · nsis`, Electron 41.2.1, Chromium 146.0.7680.188, Node 24.14.1). `v2.0.0` was promoted from this candidate during the pass and differs from it only by the version bump (`eff86dcb`), so the results hold for the stable code | Windows 11 Home 26200, 1920×1080 @ 125 %, AMD Ryzen 5 7520U / Radeon iGPU, built-in USB2.0 HD UVC WebCam (best mode 1280×720@30), Microphone Array (AMD) | Partial — 6 defects | **Whole-file pass on Windows.** Real OS mouse and keyboard input throughout. Computer-use screenshots came back grey again, so the app was observed through `PrintWindow` on its own windows and DOM reads over CDP, and every picture and sound claim below was measured on the file with ffprobe/ffmpeg. **Defects:** (1) #1004, HUD drag at 125 %: the HUD window grows about 1.5 px per drag step (1180×882 → 1232×935 over ~43 steps) and the bar jumps by half the growth on release; after a long drag down the bar sat partly under the taskbar (centre y 1042, work area ends at 1032). (2) #1005, *Edit clip*: Reset, Cancel and Apply sit inside the scrolling body. In a 1240×1000 window (794 css px tall) the card is clipped above Apply, and a click where Apply should be lands on the backdrop, closing the dialog and discarding the edit. It fits when the window is maximized. (3) #1006, the rail's "Choose a clip to edit" menu renders under the timeline toolbar: Clip 2 and Clip 3 are covered (`elementFromPoint` returns `_tlToolbar`) and clicks on them do nothing. (4) #1007, a clip duplicated with Ctrl+C / Ctrl+V does not carry its anchored zoom or Full Camera region: `duplicateClip` in `src/lib/ai-edition/document/timeline.ts` copies only `trimRanges`. (5) #1008, zoom repel across a clip boundary: a zoom dragged into a neighbour that ends at its clip's end jumps past it into the next clip, shrinking from 12.97 to 8.23 s and leaving a zero-length fragment on the first clip. Ctrl+Z restores it. (6) #1009, the wordmark menu does not close on a click on the bare top bar. The header is a `-webkit-app-region: drag` area, which never delivers the document `mousedown` that `AppMenu` listens for. It does close on the preview, on a top-bar button and on the wordmark. **Passed: HUD and capture.** One HUD, `[content-protection] OFF` logged; horizontal ↔ vertical layout; every tooltip, idle and recording, beside or above the bar and unclipped; language menu (15 locales); camera and microphone toggles in one click; device settings: three inputs, level meter, live camera preview, camera quality row (1080p persisted across a relaunch; hand-edited 720p and an absent key both read 4K). Hide bar, then the tray overflow icon brings the HUD back; Quit leaves 0 processes; a second launch exits 0. With no source the record tooltip reads "Choose a screen or window to record" and one click opens the picker, then starts. While recording: source button disabled, toggles `aria-disabled`, gear inert, tray tooltip "Recording: Tout l'écran". Pause freezes the timer and resume advances it; restart starts a new helper and deletes the first file; cancel deletes the file and opens no editor. Stop opens the editor with "Recording added to a new project". Screen H.264 High bt709 1920×1080; AAC 48 kHz; webcam 1280×720 ~30 fps at 8 Mbit/s, the camera's best mode, not upscaled, matching `webcamFormat`. Microphone-only, system-audio-only and all-off takes behave; window source 1270×668, non-black; an odd 1001×601 window gives an even 992×596 file; a context menu inside the window is recorded and cut at its edge. Without the flag the HUD and an open Notes window are absent from the take. Record mode: rows, live camera preview, microphone meter, device switch, source modal with badge, *Start recording* hands over to the HUD; auto-zoom on gives one merged zoom over three clicks, off gives none, and the setting persists; editable cursor off hides the auto-zoom row and the Cursor facet; *Hide desktop icons* shows a bare wallpaper and restores the icons after. **Passed: editor.** Rename, Saved dot, tabs, chat panel toggle, tooltips with key chips, dividers; play, pause, seek playing and paused, ±1 frame arrows, stop at end; ruler click and drag, navigator narrow and pan, labels without collision, playhead within 0.5 px; Ctrl+S toast with a stable top bar. Clips: media card drag and *Add to timeline*, reorder, Edit clip grips, 1:1 crop held through a corner drag, Free, Cancel, pencil, delete. Trim, zoom (levels, custom, out-of-range message, focus drag, 3D modes), speed (presets, custom, 16× cap message, playback at 16×), annotation (text, sizes, plates, palette, Typewriter, image, arrow, blur mosaic and smooth, oval, clamped, dragged into padding); Ctrl+D, Ctrl+Z, Ctrl+Shift+Z. Modifiers inside a trim fire on the parked frame. Copy and paste of zoom, annotation and trim with their toasts and properties; an empty copy is a no-op; deleting a clip removes its modifiers; Edit clip clamps them; a Full Camera region across a junction splits and merges as clips move. Imported music: fragments across a junction with `offsetMs`, −18 dB and 1 s fades, gain, *Reset audio*; voiceover lands at the playhead. Transcript: clip order, silences, monotonic word seeks, live cue, Backspace skip and restore, silence trim; captions in four styles and six anchors; French translation with a *Display* row, and deleting it leaves the words untouched; typing in the packaged gate does nothing; a double-click correction survives *Regenerate as English* (model reused); 101 languages, detected language on the card. Composition: colour, gradient and one-colour gradient, wallpaper, animations move during playback only (21–23 distinct frames in 3 s, None 1), blur, 9:16 with Whole and Follow cursor, Auto padding with even borders, shadows, four frame styles in both themes. Camera layout: four presets, mirror, square, size (default 40, max 60), roundness, positions; background Cutout, Blur with an intensity slider, Custom image and colour, and the custom-colour mask reaches a 720p export; webcam crop corner zoom (124 %) and frame move. Audio facet: +6.5 dB raises the export from −17.2 to −12.7 LUFS with the peak held at −1.3 dBFS; reset returns 0 dB. Cursor facet: hide, style, size (to 5.8 of 6) and 3D cursor all show in the preview. Depth of field appears once a zoom has a 3D preset and changes the preview. Wordmark menu: rows as listed, About row version, arrows wrap both ways; Keyboard Shortcuts as one dialog: Z → Q changes the lane hint, Q adds a zoom, Z does nothing, reset restores Z; Ctrl+O; AI settings as one dialog; light and dark themes, dialogs included; French UI with one-line menu rows (#969), back to English; About lists the versions and channel, and Copy puts the same block on the clipboard; the HUD panel's version row and Check for Updates ("Checking…", disabled, the same dialog as the menu, re-enabled after). AI chat (deepseek): "add one zoom at 2x from 5 s to 8 s" lands as 5–8 s at 2.20× with the reason given, is undone by one Ctrl+Z and redone. Closing the editor quits the app and writes `editor-window.json` (`maximized: false`); after a relaunch the last project's settings and the main project's two clips, crop, regions, music, voiceover and captions are as left, and a paste before any copy changes nothing. A schema-4 project from July opens, migrates to schema 8, and keeps its clip, seven zooms and annotation. **Export:** MP4 1080p30 of the two-clip project, 10288 frames, audio and video within one frame, −16.0 LUFS and −1.4 dBTP, annotation upright, caption plate at x = 108 for a 10 % inset, Full Camera where mapped, music ducked about 10 dB under speech with fades at the track's own edges, muted track absent, voiceover not stretched by a 2× region. GIF 25 fps: cancel removes the partial file and leaves the existing destination untouched; the full render (~127 s, #952) gives 434 frames, infinite loop, consistent in ffmpeg and GDI+. **Also seen:** a take with a ~4 s pause had audio 1.09 s past its video, against 0.02–0.17 s without a pause; three dedicated paused takes gave 0.40, 0.15 and 0.03 s. The export ends each clip at its last video frame (10288 frames against the 10320 the progress counted), so the timeline and the export disagree by that tail. The editor reopens 4 px taller than it closed at 125 %. **Not run:** the A/V offset across a pause measured directly (the flash-and-beep rig never painted on the captured desktop), the HUD with no camera (needs the camera disabled in Windows), tray right-click menus (Update Settings, Stop Recording, Save Diagnostics: Explorer is granted click-only), the Alt Help menu (an Alt tap showed nothing, inconclusive), Ctrl/Shift+wheel on the timeline, cursor auto-hide, smoothing, motion blur and click effects, annotation animations other than Typewriter, Depth of field in an export, chat rewind, history and Smart cuts, a software-encoder take, the crackle and hole scan, multiple displays, 4K and 1440p cameras, 150 % DPI, macOS and Linux. |
+| 2026-10-04 | dev `feat/multi-camera-recording` at `212c07f7` (feature head `23ea0751` + the HUD probe lint fix); `wgc-capture.exe` rebuilt from this tree by `npm run build:native:win` | Windows 11 on ARM64 (Snapdragon X Elite), one built-in camera (`AI Front Camera`), driven without computer-use | **Partial — the two-webcam run on site is outstanding; sub-project not complete until logged** | **Ran:** unit suite (`npm run test`, 304 of 305 files, the one failure `LeftPanel.copyMessage.test.tsx` passed alone, a load flake), both `tsc`, lint (0 errors, 26 warnings, the base count), `i18n:check`; the helper's native unit tests (`node scripts/build-windows-wgc-helper.mjs`, all pass); helper smoke runs `npm run test:wgc-helper:win`, `-- --webcam` and `-- --webcam --missing-second-webcam` (index 1 dropped and named, camera 1 kept); a direct helper run listing the one camera twice: camera 1 recorded, camera 2 dropped with `webcam-unavailable` index 1 and "already recording in this take", `webcamPaths` held one file, exit 0, camera file 4.81 s against the screen's 4.80 s. **Not run:** the app click-through (HUD *Additional cameras*, editor, save and reopen, the session manifest's `additionalWebcams`, the "Not recorded" notice): no computer-use here and only one camera. **Not covered at all:** two real cameras recording together, identical-name Brios, 1080p and 4K load, clap sync, macOS and Linux. |

From 1607b29ce2422518d18fb74e26dbb3be676e0bf3 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 13:18:35 +0200
Subject: [PATCH 13/22] fix(project): no fixed limit on additional camera
 tracks

The recorder caps at three extra cameras, but a validator that ships with a
cap cannot be loosened later for older builds. The HUD and Electron still cap.
---
 src/lib/ai-edition/schema/index.test.ts | 8 ++++----
 src/lib/ai-edition/schema/index.ts      | 4 +++-
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/lib/ai-edition/schema/index.test.ts b/src/lib/ai-edition/schema/index.test.ts
index bb8148e9c..adc99c418 100644
--- a/src/lib/ai-edition/schema/index.test.ts
+++ b/src/lib/ai-edition/schema/index.test.ts
@@ -295,11 +295,11 @@ describe("axcut-schema v8", () => {
 			expect(additionalCameraTrackSchema.safeParse({ sourcePath: "" }).success).toBe(false);
 		});
 
-		it("rejects more than three additional cameras", () => {
+		it("accepts more than three additional cameras: the list has no fixed limit", () => {
 			const entries = Array.from({ length: 5 }, (_, i) => ({ sourcePath: `/c${i}.mp4` }));
-			expect(assetSchema.safeParse({ ...base, additionalCameraTracks: entries }).success).toBe(
-				false,
-			);
+			const parsed = assetSchema.safeParse({ ...base, additionalCameraTracks: entries });
+			expect(parsed.success).toBe(true);
+			expect(parsed.data?.additionalCameraTracks).toHaveLength(5);
 		});
 	});
 
diff --git a/src/lib/ai-edition/schema/index.ts b/src/lib/ai-edition/schema/index.ts
index 02702afc1..495b93b09 100644
--- a/src/lib/ai-edition/schema/index.ts
+++ b/src/lib/ai-edition/schema/index.ts
@@ -207,7 +207,9 @@ export const assetSchema = z.object({
 	// no schema-version bump (an older build simply drops the key on save).
 	transcriptionFailure: assetTranscriptionFailureSchema.nullish(),
 	cameraTrack: cameraTrackSchema,
-	additionalCameraTracks: z.array(additionalCameraTrackSchema).max(3).optional(),
+	// No fixed limit on purpose: the recorder caps at three today, but a
+	// validator that ships with a cap cannot be loosened for older builds.
+	additionalCameraTracks: z.array(additionalCameraTrackSchema).optional(),
 });
 
 // A crop is a sub-rectangle of the source video, expressed as fractions

From 3f3eb2c5d64c12d95fd84bf078762985e3dd80f4 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 13:18:56 +0200
Subject: [PATCH 14/22] fix(recording): never match identical cameras by name
 across an id

Two webcams of the same model share a name. When an extra carries a deviceId
and camera 1 does not, the name says nothing about whether they are the same
device, so the extra is no longer dropped as a duplicate of camera 1.
---
 electron/recording/nativeWindowsWebcams.test.ts | 13 +++++++++++++
 electron/recording/nativeWindowsWebcams.ts      | 10 +++++++++-
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/electron/recording/nativeWindowsWebcams.test.ts b/electron/recording/nativeWindowsWebcams.test.ts
index ffd0ea56e..9c86d4fde 100644
--- a/electron/recording/nativeWindowsWebcams.test.ts
+++ b/electron/recording/nativeWindowsWebcams.test.ts
@@ -62,6 +62,19 @@ describe("nativeWindowsWebcams", () => {
 		);
 	});
 
+	it("never matches an extra with an id to an id-less camera 1 by name", () => {
+		// Two cameras of the same model: same name, and camera 1 came without an id.
+		expect(
+			dedupeAdditionalWebcams({ deviceName: "USB Camera" }, [
+				{ deviceId: "b", deviceName: "USB Camera" },
+			]),
+		).toEqual([{ deviceId: "b", deviceName: "USB Camera" }]);
+		// Without an id on either side the name is all there is, and it still matches.
+		expect(
+			dedupeAdditionalWebcams({ deviceName: "USB Camera" }, [{ deviceName: "USB Camera" }]),
+		).toEqual([]);
+	});
+
 	it("drops an empty additional camera file and names it", () => {
 		const r = collectStoppedWebcams({
 			camera1Enabled: true,
diff --git a/electron/recording/nativeWindowsWebcams.ts b/electron/recording/nativeWindowsWebcams.ts
index 08a797082..23e0bb492 100644
--- a/electron/recording/nativeWindowsWebcams.ts
+++ b/electron/recording/nativeWindowsWebcams.ts
@@ -47,11 +47,19 @@ export interface HelperWebcamEntry {
 
 type DeviceRef = { deviceId?: string; deviceName?: string };
 
-/** Same device: by id when both sides carry one, otherwise by name. */
+/**
+ * Same device: by id when both sides carry one, otherwise by name — but only
+ * when neither carries an id. Two webcams of the same model share a name, so an
+ * id on one side and none on the other says nothing about whether they are the
+ * same device, and matching by name there would silently drop the second one.
+ */
 function isSameDevice(a: DeviceRef, b: DeviceRef) {
 	if (a.deviceId && b.deviceId) {
 		return a.deviceId === b.deviceId;
 	}
+	if (a.deviceId || b.deviceId) {
+		return false;
+	}
 	const name = a.deviceName?.trim();
 	return Boolean(name) && name === b.deviceName?.trim();
 }

From 21c848ee852f0d8502d89e3d5853df4f0fea4ecf Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 13:19:39 +0200
Subject: [PATCH 15/22] fix(wgc): report a camera file that could not be
 removed

The helper deletes the file of a camera it drops at start, but ignored a
failed DeleteFileW. It now logs a WARNING with the path and GetLastError, and
Electron keeps the dropped cameras' paths so stop and discard remove a 0-byte
stub left behind.
---
 electron/ipc/handlers.ts                 | 35 ++++++++++++++++++++++++
 electron/native/wgc-capture/src/main.cpp | 11 +++++++-
 2 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index 191250fcd..520e18787 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -763,6 +763,11 @@ let nativeWindowsCaptureWebcamTargetPath: string | null = null;
  * the label it is reported under. Only paths generated here ever land in it.
  */
 let nativeWindowsCaptureAdditionalWebcamTargets: Array<{ path: string; label: string }> = [];
+/**
+ * Files of cameras the helper dropped at start. The helper deletes them, but a
+ * delete that failed leaves a 0-byte stub; stop and discard remove it if empty.
+ */
+let nativeWindowsCaptureDroppedWebcamPaths: string[] = [];
 let nativeWindowsCaptureRecordingId: number | null = null;
 let nativeWindowsCursorOffsetMs = 0;
 let nativeWindowsCursorCaptureMode: CursorCaptureMode = "editable-overlay";
@@ -790,6 +795,7 @@ function resetNativeWindowsCaptureState() {
 	nativeWindowsCaptureTargetPath = null;
 	nativeWindowsCaptureWebcamTargetPath = null;
 	nativeWindowsCaptureAdditionalWebcamTargets = [];
+	nativeWindowsCaptureDroppedWebcamPaths = [];
 	nativeWindowsCaptureRecordingId = null;
 	nativeWindowsCursorOffsetMs = 0;
 	nativeWindowsCursorCaptureMode = "editable-overlay";
@@ -848,6 +854,22 @@ async function removeNativeWindowsCaptureOutputs(
 		}
 	}
 }
+
+/** Removes the 0-byte stubs of cameras dropped at start; anything with data stays. */
+async function removeEmptyNativeWindowsWebcamFiles(paths: string[]) {
+	for (const target of paths) {
+		if (!isPathWithinDir(target, RECORDINGS_DIR)) {
+			continue;
+		}
+		const stats = await fs.stat(target).catch(() => null);
+		if (stats?.size !== 0) {
+			continue;
+		}
+		await fs.rm(target, { force: true }).catch((error) => {
+			console.warn("[native-wgc] could not remove an empty camera file:", target, error);
+		});
+	}
+}
 let nativeMacCaptureProcess: ChildProcessWithoutNullStreams | null = null;
 /**
  * Apple's system picker session (macOS 15.2+), started on first use and kept for the app's
@@ -2999,6 +3021,7 @@ export function registerIpcHandlers(
 				nativeWindowsCaptureAdditionalWebcamTargets = additionalWebcams.map(
 					({ label, path: cameraPath }) => ({ label, path: cameraPath }),
 				);
+				nativeWindowsCaptureDroppedWebcamPaths = [];
 				nativeWindowsCaptureRecordingId = recordingId;
 				nativeWindowsCursorOffsetMs = 0;
 				nativeWindowsCursorCaptureMode = cursorCaptureMode;
@@ -3097,6 +3120,13 @@ export function registerIpcHandlers(
 				const unavailableWebcams = request.webcam.enabled
 					? labelsOfUnavailableAdditionalWebcams(startedWebcams, [...unavailableWebcamIndices])
 					: [];
+				// The helper deletes a dropped camera's file but may fail to; a stub
+				// left behind is removed at stop or discard if it is still empty.
+				nativeWindowsCaptureDroppedWebcamPaths = request.webcam.enabled
+					? startedWebcams
+							.filter((_, i) => unavailableWebcamIndices.has(i))
+							.map((camera) => camera.path)
+					: [];
 				if (unavailableWebcams.length > 0) {
 					console.warn(
 						"[native-wgc] recording without additional cameras the helper could not open",
@@ -3457,9 +3487,13 @@ export function registerIpcHandlers(
 		const preferredPath = nativeWindowsCaptureTargetPath;
 		const preferredWebcamPath = nativeWindowsCaptureWebcamTargetPath;
 		const additionalWebcamTargets = nativeWindowsCaptureAdditionalWebcamTargets;
+		const droppedWebcamPaths = nativeWindowsCaptureDroppedWebcamPaths;
+		// Start-dropped cameras ride along so a discard or a failed stop also
+		// removes a stub the helper could not delete (both are empty).
 		const allWebcamPaths = [
 			preferredWebcamPath,
 			...additionalWebcamTargets.map((target) => target.path),
+			...droppedWebcamPaths,
 		];
 		const recordingId = nativeWindowsCaptureRecordingId ?? Date.now();
 		const cursorCaptureMode = nativeWindowsCursorCaptureMode;
@@ -3631,6 +3665,7 @@ export function registerIpcHandlers(
 					helperWebcamPaths: readStoppedWebcamPaths(nativeWindowsCaptureOutput),
 				});
 			}
+			await removeEmptyNativeWindowsWebcamFiles(droppedWebcamPaths);
 			// Generated by the start handler, never taken from the renderer or the
 			// helper; approved like the session's other media.
 			for (const extra of additionalWebcams) {
diff --git a/electron/native/wgc-capture/src/main.cpp b/electron/native/wgc-capture/src/main.cpp
index e7a18082e..09983e45d 100644
--- a/electron/native/wgc-capture/src/main.cpp
+++ b/electron/native/wgc-capture/src/main.cpp
@@ -773,7 +773,16 @@ int wmain(int argc, wchar_t* argv[]) {
             // Balances whatever initialize() got through, then removes the
             // file it may have created: nothing was ever written to it.
             stream.encoder.finalize();
-            DeleteFileW(utf8ToWide(stream.config.outputPath).c_str());
+            // A file that never got created is fine; one that could not be
+            // removed is left as a 0-byte stub, which the app cleans up.
+            if (!DeleteFileW(utf8ToWide(stream.config.outputPath).c_str())) {
+                const DWORD deleteError = GetLastError();
+                if (deleteError != ERROR_FILE_NOT_FOUND) {
+                    std::cerr << "WARNING: Could not remove the dropped camera file "
+                              << stream.config.outputPath << " (GetLastError=" << deleteError << ")"
+                              << std::endl;
+                }
+            }
         }
         stream.active = false;
         if (inlineWebcam == &stream) {

From 31e8d3190d6c90bcb1645b6e6b6b66723c96c709 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 13:20:00 +0200
Subject: [PATCH 16/22] feat(recording): name a camera that stopped early

A camera the helper disables mid-take keeps its partial file in the take, but
nobody was told. A camera whose file was kept (size > 0) yet is missing from
recording-stopped.webcamPaths is now named in a "Stopped early" notice after
the take, camera 1 included. Paths compare case-insensitively with either
separator. Only an event that carries webcamPaths can say so, so the helper now
prints the list, possibly empty, whenever a camera wrote a file of its own; an
older helper or a missing event never produces the notice.
---
 electron/electron-env.d.ts                    |  5 ++
 electron/ipc/handlers.ts                      | 23 ++++++++-
 electron/native/README.md                     |  2 +-
 electron/native/wgc-capture/src/main.cpp      |  7 ++-
 .../nativeWindowsCaptureStop.test.ts          | 13 +++++
 .../recording/nativeWindowsCaptureStop.ts     | 29 ++++++++---
 .../recording/nativeWindowsWebcams.test.ts    | 50 +++++++++++++++++++
 electron/recording/nativeWindowsWebcams.ts    | 33 ++++++++++++
 ...eScreenRecorder.nativeStopFailure.test.tsx | 16 ++++++
 src/hooks/useScreenRecorder.ts                |  9 ++++
 src/i18n/locales/ar/launch.json               |  1 +
 src/i18n/locales/cs/launch.json               |  1 +
 src/i18n/locales/de/launch.json               |  1 +
 src/i18n/locales/en/launch.json               |  1 +
 src/i18n/locales/es/launch.json               |  1 +
 src/i18n/locales/fr/launch.json               |  1 +
 src/i18n/locales/it/launch.json               |  1 +
 src/i18n/locales/ja-JP/launch.json            |  1 +
 src/i18n/locales/ko-KR/launch.json            |  1 +
 src/i18n/locales/pt-BR/launch.json            |  1 +
 src/i18n/locales/ru/launch.json               |  1 +
 src/i18n/locales/tr/launch.json               |  1 +
 src/i18n/locales/vi/launch.json               |  1 +
 src/i18n/locales/zh-CN/launch.json            |  1 +
 src/i18n/locales/zh-TW/launch.json            |  1 +
 25 files changed, 192 insertions(+), 10 deletions(-)

diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.ts
index 99b2a3f79..1c28c8b4f 100644
--- a/electron/electron-env.d.ts
+++ b/electron/electron-env.d.ts
@@ -183,6 +183,11 @@ interface Window {
 			 * `webcamDropped`.
 			 */
 			droppedWebcams?: string[];
+			/**
+			 * Labels of cameras (camera 1 included) that the helper disabled mid-take.
+			 * Their partial files are kept in the session; the user is told which.
+			 */
+			webcamsStoppedEarly?: string[];
 		}>;
 		pauseNativeWindowsRecording: () => Promise<{
 			success: boolean;
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index 520e18787..f1cbfe31f 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -123,6 +123,7 @@ import {
 	NATIVE_WINDOWS_SALVAGEABLE_OUTPUT_BYTES,
 	readMicrophoneDefaulted,
 	readMicrophoneUnavailable,
+	readReportedWebcamPaths,
 	readSecondaryWindowsApplied,
 	readStoppedWebcamPaths,
 	readUnavailableWebcamIndices,
@@ -137,6 +138,7 @@ import {
 	dedupeAdditionalWebcams,
 	isWebcamSidecarFile,
 	labelsOfUnavailableAdditionalWebcams,
+	labelsOfWebcamsStoppedEarly,
 	stripWebcamSuffix,
 	webcamOutputPath,
 } from "../recording/nativeWindowsWebcams";
@@ -763,6 +765,8 @@ let nativeWindowsCaptureWebcamTargetPath: string | null = null;
  * the label it is reported under. Only paths generated here ever land in it.
  */
 let nativeWindowsCaptureAdditionalWebcamTargets: Array<{ path: string; label: string }> = [];
+/** Camera 1's label for notices: its device name, else "Camera 1". */
+let nativeWindowsCaptureWebcamLabel = "Camera 1";
 /**
  * Files of cameras the helper dropped at start. The helper deletes them, but a
  * delete that failed leaves a 0-byte stub; stop and discard remove it if empty.
@@ -795,6 +799,7 @@ function resetNativeWindowsCaptureState() {
 	nativeWindowsCaptureTargetPath = null;
 	nativeWindowsCaptureWebcamTargetPath = null;
 	nativeWindowsCaptureAdditionalWebcamTargets = [];
+	nativeWindowsCaptureWebcamLabel = "Camera 1";
 	nativeWindowsCaptureDroppedWebcamPaths = [];
 	nativeWindowsCaptureRecordingId = null;
 	nativeWindowsCursorOffsetMs = 0;
@@ -3021,6 +3026,7 @@ export function registerIpcHandlers(
 				nativeWindowsCaptureAdditionalWebcamTargets = additionalWebcams.map(
 					({ label, path: cameraPath }) => ({ label, path: cameraPath }),
 				);
+				nativeWindowsCaptureWebcamLabel = request.webcam.deviceName?.trim() || "Camera 1";
 				nativeWindowsCaptureDroppedWebcamPaths = [];
 				nativeWindowsCaptureRecordingId = recordingId;
 				nativeWindowsCursorOffsetMs = 0;
@@ -3487,6 +3493,7 @@ export function registerIpcHandlers(
 		const preferredPath = nativeWindowsCaptureTargetPath;
 		const preferredWebcamPath = nativeWindowsCaptureWebcamTargetPath;
 		const additionalWebcamTargets = nativeWindowsCaptureAdditionalWebcamTargets;
+		const camera1Label = nativeWindowsCaptureWebcamLabel;
 		const droppedWebcamPaths = nativeWindowsCaptureDroppedWebcamPaths;
 		// Start-dropped cameras ride along so a discard or a failed stop also
 		// removes a stub the helper could not delete (both are empty).
@@ -3637,7 +3644,7 @@ export function registerIpcHandlers(
 			// (getopenscreen/openscreen#387). Every camera is judged by its own file,
 			// not by the helper's list at stop (see `collectStoppedWebcams`).
 			const requestedWebcams = [
-				...(preferredWebcamPath ? [{ path: preferredWebcamPath, label: "" }] : []),
+				...(preferredWebcamPath ? [{ path: preferredWebcamPath, label: camera1Label }] : []),
 				...additionalWebcamTargets,
 			];
 			const webcamSizes = new Map<string, number>();
@@ -3665,6 +3672,19 @@ export function registerIpcHandlers(
 					helperWebcamPaths: readStoppedWebcamPaths(nativeWindowsCaptureOutput),
 				});
 			}
+			// A camera the helper disabled mid-take keeps its partial file (it is
+			// in the take) but is named, so the user knows why it ends early. Only
+			// a helper that sends `webcamPaths` can tell; otherwise nothing is said.
+			const webcamsStoppedEarly = labelsOfWebcamsStoppedEarly({
+				requested: requestedWebcams,
+				sizes: webcamSizes,
+				helperWebcamPaths: readReportedWebcamPaths(nativeWindowsCaptureOutput),
+			});
+			if (webcamsStoppedEarly.length > 0) {
+				console.warn("[native-wgc] cameras stopped before the end of the take", {
+					webcamsStoppedEarly,
+				});
+			}
 			await removeEmptyNativeWindowsWebcamFiles(droppedWebcamPaths);
 			// Generated by the start handler, never taken from the renderer or the
 			// helper; approved like the session's other media.
@@ -3706,6 +3726,7 @@ export function registerIpcHandlers(
 				// the silence this change exists to end.
 				webcamDropped: Boolean(preferredWebcamPath) && !webcamVideoPath,
 				...(stoppedWebcams.dropped.length > 0 ? { droppedWebcams: stoppedWebcams.dropped } : {}),
+				...(webcamsStoppedEarly.length > 0 ? { webcamsStoppedEarly } : {}),
 				message: recovered
 					? "Native Windows recording recovered from a failed stop"
 					: "Native Windows recording session stored successfully",
diff --git a/electron/native/README.md b/electron/native/README.md
index 316622866..931a91471 100644
--- a/electron/native/README.md
+++ b/electron/native/README.md
@@ -94,7 +94,7 @@ Several cameras: a `webcams` list records up to four cameras, each into its own
 ]
 ```
 
-Every per-camera event carries the camera's `index` in that list: `webcam-format` (`{"event":"webcam-format","schemaVersion":2,"index":0,"width":…,"height":…,"fps":…,"deviceName":"…"}`) for each camera that opened, and `{"event":"warning","code":"webcam-unavailable","index":1,"deviceName":"…","message":"…"}` for each that did not (`code` comes before `index` so older substring readers still match). A camera that cannot be opened, or whose encoder or capture will not start (the message says which), is dropped and the rest of the take goes on; a camera whose encoder rejects a sample mid-take is disabled on its own, without stopping the screen or the other cameras. `recording-stopped` keeps `webcamPath` (camera 0, when it recorded) and adds `webcamPaths`, the files of every camera still recording at stop, in index order. Both are printed before the camera files are finalized (see the stop sequence), so a camera whose finalize fails is reported on stderr and by a non-zero exit, not removed from the list. Each camera finalizes in its own `[stop-timing]` step, `webcam-encoder-finalize-<index>`.
+Every per-camera event carries the camera's `index` in that list: `webcam-format` (`{"event":"webcam-format","schemaVersion":2,"index":0,"width":…,"height":…,"fps":…,"deviceName":"…"}`) for each camera that opened, and `{"event":"warning","code":"webcam-unavailable","index":1,"deviceName":"…","message":"…"}` for each that did not (`code` comes before `index` so older substring readers still match). A camera that cannot be opened, or whose encoder or capture will not start (the message says which), is dropped and the rest of the take goes on; a camera whose encoder rejects a sample mid-take is disabled on its own, without stopping the screen or the other cameras. `recording-stopped` keeps `webcamPath` (camera 0, when it recorded) and adds `webcamPaths`, the files of every camera still recording at stop, in index order — an empty list when every camera that wrote a file of its own was disabled mid-take, so a reader can tell "stopped early" from an older helper that never sends the key. Both are printed before the camera files are finalized (see the stop sequence), so a camera whose finalize fails is reported on stderr and by a non-zero exit, not removed from the list. Each camera finalizes in its own `[stop-timing]` step, `webcam-encoder-finalize-<index>`.
 
 Container: recordings are written as fragmented MP4 (`MFCreateFMPEG4MediaSink` + `MFCreateSinkWriterFromMediaSink`, `MF_MPEG4SINK_MIN_FRAGMENT_DURATION` = 1s) rather than plain MP4. A plain MP4 has no index until `IMFSinkWriter::Finalize()` writes `moov` at the very end, so when the shutdown watchdog force-exits a wedged helper the file on disk holds every frame and no way to read them — that is why issues #252 / #292 / #327 cost the whole recording rather than the frozen tail of it. A fragmented MP4 writes its index up front and its samples in self-describing `moof`+`mdat` pairs, so the same kill leaves a file that plays up to the last complete fragment. This does not fix the freeze; it removes the data loss the freeze causes. Because the fragmented sink needs both output media types at construction, the sink writer is built from a media sink instead of from a URL, and the helper reads the video/audio stream positions back off the sink rather than assuming them. If any of that is unavailable on a machine, the helper retries with the plain container and says so — `container` in the `encoder-selection` event is `fragmented-mp4` or `mp4`, and it reports what was used, not what was asked for.
 
diff --git a/electron/native/wgc-capture/src/main.cpp b/electron/native/wgc-capture/src/main.cpp
index 09983e45d..f6b4c8ffd 100644
--- a/electron/native/wgc-capture/src/main.cpp
+++ b/electron/native/wgc-capture/src/main.cpp
@@ -1832,8 +1832,13 @@ int wmain(int argc, wchar_t* argv[]) {
         // before the camera files are finalized, for the reason above -- so they
         // name the files that were being written, and a camera whose finalize
         // fails below is reported on stderr, not removed from this list.
+        // `webcamPaths` is printed, possibly empty, whenever a camera wrote a
+        // file of its own: its presence is how the app knows a camera missing
+        // from it stopped early, rather than an older helper that never sent it.
         std::vector<const WebcamStream*> recordedWebcams;
+        bool anySeparateWebcam = false;
         for (const auto& stream : webcams) {
+            anySeparateWebcam = anySeparateWebcam || stream->writeSeparate;
             if (stream->writeSeparate && stream->active) {
                 recordedWebcams.push_back(stream.get());
             }
@@ -1842,7 +1847,7 @@ int wmain(int argc, wchar_t* argv[]) {
             std::cout << ",\"webcamPath\":\"" << jsonEscape(recordedWebcams.front()->config.outputPath)
                       << "\"";
         }
-        if (!recordedWebcams.empty()) {
+        if (anySeparateWebcam) {
             std::cout << ",\"webcamPaths\":[";
             for (size_t i = 0; i < recordedWebcams.size(); ++i) {
                 std::cout << (i == 0 ? "\"" : ",\"") << jsonEscape(recordedWebcams[i]->config.outputPath)
diff --git a/electron/recording/nativeWindowsCaptureStop.test.ts b/electron/recording/nativeWindowsCaptureStop.test.ts
index 6391569c2..0def7936f 100644
--- a/electron/recording/nativeWindowsCaptureStop.test.ts
+++ b/electron/recording/nativeWindowsCaptureStop.test.ts
@@ -7,6 +7,7 @@ import {
 	NATIVE_WINDOWS_SALVAGEABLE_OUTPUT_BYTES,
 	readMicrophoneDefaulted,
 	readMicrophoneUnavailable,
+	readReportedWebcamPaths,
 	readSecondaryWindowsApplied,
 	readStoppedPath,
 	readStoppedWebcamPaths,
@@ -593,6 +594,18 @@ describe("per-camera helper events", () => {
 		expect(readStoppedWebcamPaths('{"event":"recording-stopped"}')).toEqual([]);
 	});
 
+	it("tells a reported webcamPaths list apart from its absence", () => {
+		expect(
+			readReportedWebcamPaths('{"event":"recording-stopped","webcamPaths":["a.mp4","b.mp4"]}'),
+		).toEqual(["a.mp4", "b.mp4"]);
+		expect(readReportedWebcamPaths('{"event":"recording-stopped","webcamPaths":[]}')).toEqual([]);
+		// An old helper sends only the legacy path; that is "unknown", not "none".
+		expect(
+			readReportedWebcamPaths('{"event":"recording-stopped","webcamPath":"a.mp4"}'),
+		).toBeNull();
+		expect(readReportedWebcamPaths("Recording stopped. Output path: s.mp4")).toBeNull();
+	});
+
 	it("reads JSON-escaped Windows paths behind a prefix", () => {
 		const line =
 			'INFO: x {"event":"recording-stopped","schemaVersion":2,"screenPath":"C:\\\\Users\\\\me\\\\s.mp4","webcamPath":"C:\\\\Users\\\\me\\\\s-webcam.mp4","webcamPaths":["C:\\\\Users\\\\me\\\\s-webcam.mp4","C:\\\\Users\\\\me\\\\s-webcam-2.mp4"]}';
diff --git a/electron/recording/nativeWindowsCaptureStop.ts b/electron/recording/nativeWindowsCaptureStop.ts
index 824cf4b3c..05c2a0f1f 100644
--- a/electron/recording/nativeWindowsCaptureStop.ts
+++ b/electron/recording/nativeWindowsCaptureStop.ts
@@ -275,19 +275,34 @@ export function readWebcamFormatAt(
 	return (match as ReturnType<typeof readWebcamFormat>) ?? null;
 }
 
+/**
+ * The `webcamPaths` list of the last `recording-stopped` event, or null when
+ * there is no such event or it carried no `webcamPaths` key.
+ *
+ * Null is the signal that matters: only a helper that sends the key says which
+ * cameras were still recording at stop, so only then may a camera missing from
+ * it be called one that stopped early. An old helper, or a stop without the
+ * event, must read as "unknown", never as "every camera stopped".
+ */
+export function readReportedWebcamPaths(output: string): string[] | null {
+	const event = readHelperEvents(output, "recording-stopped").at(-1);
+	if (!event || !Array.isArray(event.webcamPaths)) {
+		return null;
+	}
+	return event.webcamPaths.filter((entry): entry is string => typeof entry === "string");
+}
+
 /**
  * Camera files the helper reported at stop: `webcamPaths`, else the single
  * legacy `webcamPath`, else none.
  */
 export function readStoppedWebcamPaths(output: string): string[] {
-	const event = readHelperEvents(output, "recording-stopped").at(-1);
-	if (!event) {
-		return [];
+	const reported = readReportedWebcamPaths(output);
+	if (reported) {
+		return reported;
 	}
-	if (Array.isArray(event.webcamPaths)) {
-		return event.webcamPaths.filter((entry): entry is string => typeof entry === "string");
-	}
-	return typeof event.webcamPath === "string" && event.webcamPath ? [event.webcamPath] : [];
+	const event = readHelperEvents(output, "recording-stopped").at(-1);
+	return typeof event?.webcamPath === "string" && event.webcamPath ? [event.webcamPath] : [];
 }
 
 /**
diff --git a/electron/recording/nativeWindowsWebcams.test.ts b/electron/recording/nativeWindowsWebcams.test.ts
index 9c86d4fde..f7187851c 100644
--- a/electron/recording/nativeWindowsWebcams.test.ts
+++ b/electron/recording/nativeWindowsWebcams.test.ts
@@ -6,6 +6,7 @@ import {
 	dedupeAdditionalWebcams,
 	isWebcamSidecarFile,
 	labelsOfUnavailableAdditionalWebcams,
+	labelsOfWebcamsStoppedEarly,
 	stripWebcamSuffix,
 	webcamOutputPath,
 } from "./nativeWindowsWebcams";
@@ -75,6 +76,55 @@ describe("nativeWindowsWebcams", () => {
 		).toEqual([]);
 	});
 
+	describe("labelsOfWebcamsStoppedEarly", () => {
+		const front = String.raw`C:\Rec\r-webcam.mp4`;
+		const desk = String.raw`C:\Rec\r-webcam-2.mp4`;
+		const side = String.raw`C:\Rec\r-webcam-3.mp4`;
+		const requested = [
+			{ path: front, label: "Front" },
+			{ path: desk, label: "Desk" },
+			{ path: side, label: "Side" },
+		];
+		const sizes = new Map([
+			[front, 100],
+			[desk, 100],
+			[side, 0],
+		]);
+
+		it("names a kept camera the helper no longer listed, camera 1 included", () => {
+			expect(
+				labelsOfWebcamsStoppedEarly({
+					requested,
+					sizes,
+					helperWebcamPaths: [desk],
+				}),
+			).toEqual(["Front"]);
+		});
+
+		it("leaves out a camera whose file was not kept: that one was not recorded", () => {
+			expect(labelsOfWebcamsStoppedEarly({ requested, sizes, helperWebcamPaths: [] })).toEqual([
+				"Front",
+				"Desk",
+			]);
+		});
+
+		it("flags nothing without a webcamPaths key", () => {
+			expect(labelsOfWebcamsStoppedEarly({ requested, sizes, helperWebcamPaths: null })).toEqual(
+				[],
+			);
+		});
+
+		it("matches paths regardless of case and separator", () => {
+			expect(
+				labelsOfWebcamsStoppedEarly({
+					requested,
+					sizes,
+					helperWebcamPaths: ["c:/rec/R-WEBCAM.mp4", String.raw`c:\REC//r-webcam-2.MP4`],
+				}),
+			).toEqual([]);
+		});
+	});
+
 	it("drops an empty additional camera file and names it", () => {
 		const r = collectStoppedWebcams({
 			camera1Enabled: true,
diff --git a/electron/recording/nativeWindowsWebcams.ts b/electron/recording/nativeWindowsWebcams.ts
index 23e0bb492..9c8b462b5 100644
--- a/electron/recording/nativeWindowsWebcams.ts
+++ b/electron/recording/nativeWindowsWebcams.ts
@@ -234,3 +234,36 @@ export function collectStoppedWebcams(input: {
 	}
 	return { ...(camera1 ? { camera1 } : {}), additional, dropped };
 }
+
+/** A path compared the way Windows does: case-insensitive, either separator. */
+function comparablePath(filePath: string) {
+	return filePath.replace(/[\\/]+/g, "\\").toLowerCase();
+}
+
+/**
+ * Labels of the cameras that stopped early: their file was kept (size > 0, the
+ * same test as {@link collectStoppedWebcams}) but the helper did not list it in
+ * `recording-stopped.webcamPaths`, the cameras still recording at stop. That is
+ * a camera the helper disabled mid-take; its partial file stays in the take,
+ * and the user is told which camera it was.
+ *
+ * `helperWebcamPaths` is null when the event carried no `webcamPaths` key (an
+ * old helper, or no event at all) — then nothing is known and nothing is
+ * flagged. Camera 1 counts like any other, so its entry needs a real label.
+ */
+export function labelsOfWebcamsStoppedEarly(input: {
+	requested: Array<{ path: string; label: string }>;
+	sizes: Map<string, number>;
+	helperWebcamPaths: string[] | null;
+}): string[] {
+	if (!input.helperWebcamPaths) {
+		return [];
+	}
+	const stillRecording = new Set(input.helperWebcamPaths.map(comparablePath));
+	return input.requested
+		.filter(
+			(camera) =>
+				(input.sizes.get(camera.path) ?? 0) > 0 && !stillRecording.has(comparablePath(camera.path)),
+		)
+		.map((camera) => camera.label);
+}
diff --git a/src/hooks/useScreenRecorder.nativeStopFailure.test.tsx b/src/hooks/useScreenRecorder.nativeStopFailure.test.tsx
index 928ac5886..5e761e3ea 100644
--- a/src/hooks/useScreenRecorder.nativeStopFailure.test.tsx
+++ b/src/hooks/useScreenRecorder.nativeStopFailure.test.tsx
@@ -137,4 +137,20 @@ describe("useScreenRecorder native Windows stop failure", () => {
 		expect(api.switchToEditor).toHaveBeenCalled();
 		expect(view.result.current.recording).toBe(false);
 	});
+
+	it("names the cameras that stopped early and still opens the editor", async () => {
+		vi.mocked(toast.warning).mockClear();
+		api.stopNativeWindowsRecording.mockResolvedValue({
+			success: true,
+			path: "C:\\rec\\a.mp4",
+			webcamsStoppedEarly: ["Front", "Desk"],
+		});
+
+		const view = renderHook(() => useScreenRecorder());
+		await startNativeRecording(view);
+		await pressStop(view);
+
+		expect(toast.warning).toHaveBeenCalledWith("webcam.camerasStoppedEarly");
+		expect(api.switchToEditor).toHaveBeenCalled();
+	});
 });
diff --git a/src/hooks/useScreenRecorder.ts b/src/hooks/useScreenRecorder.ts
index a5a88cdfa..177d7667b 100644
--- a/src/hooks/useScreenRecorder.ts
+++ b/src/hooks/useScreenRecorder.ts
@@ -813,6 +813,15 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 					}),
 				);
 			}
+			// Kept in the take, but shorter than it: the helper disabled these
+			// cameras mid-take, so the editor shows them ending early.
+			if (result.webcamsStoppedEarly?.length) {
+				toast.warning(
+					tLaunchRef.current("webcam.camerasStoppedEarly", {
+						names: result.webcamsStoppedEarly.join(", "),
+					}),
+				);
+			}
 			if (result.session) {
 				await window.electronAPI.setCurrentRecordingSession(result.session);
 			} else if (result.path) {
diff --git a/src/i18n/locales/ar/launch.json b/src/i18n/locales/ar/launch.json
index 858d9d8e9..365845783 100644
--- a/src/i18n/locales/ar/launch.json
+++ b/src/i18n/locales/ar/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "كاميرات إضافية",
 		"additionalCamerasHint": "فقط مع التسجيل الأصلي في Windows",
 		"camerasNotRecorded": "لم يتم تسجيلها: {{names}}",
+		"camerasStoppedEarly": "توقفت مبكرًا: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/cs/launch.json b/src/i18n/locales/cs/launch.json
index d79eb409b..89b34c7c3 100644
--- a/src/i18n/locales/cs/launch.json
+++ b/src/i18n/locales/cs/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "Další kamery",
 		"additionalCamerasHint": "Pouze s nativním nahráváním ve Windows",
 		"camerasNotRecorded": "Nenahráno: {{names}}",
+		"camerasStoppedEarly": "Zastaveno předčasně: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/de/launch.json b/src/i18n/locales/de/launch.json
index 2ba2310d7..de7926b50 100644
--- a/src/i18n/locales/de/launch.json
+++ b/src/i18n/locales/de/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "Weitere Kameras",
 		"additionalCamerasHint": "Nur bei nativer Windows-Aufnahme",
 		"camerasNotRecorded": "Nicht aufgenommen: {{names}}",
+		"camerasStoppedEarly": "Vorzeitig beendet: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/en/launch.json b/src/i18n/locales/en/launch.json
index 2489623aa..478e0c5ef 100644
--- a/src/i18n/locales/en/launch.json
+++ b/src/i18n/locales/en/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "Additional cameras",
 		"additionalCamerasHint": "Only with native Windows recording",
 		"camerasNotRecorded": "Not recorded: {{names}}",
+		"camerasStoppedEarly": "Stopped early: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/es/launch.json b/src/i18n/locales/es/launch.json
index 565d4a852..85fd72d02 100644
--- a/src/i18n/locales/es/launch.json
+++ b/src/i18n/locales/es/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "Cámaras adicionales",
 		"additionalCamerasHint": "Solo con la grabación nativa de Windows",
 		"camerasNotRecorded": "No grabadas: {{names}}",
+		"camerasStoppedEarly": "Se detuvieron antes de tiempo: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/fr/launch.json b/src/i18n/locales/fr/launch.json
index 0cc342866..1f6815556 100644
--- a/src/i18n/locales/fr/launch.json
+++ b/src/i18n/locales/fr/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "Caméras supplémentaires",
 		"additionalCamerasHint": "Uniquement avec l'enregistrement natif sous Windows",
 		"camerasNotRecorded": "Non enregistrées : {{names}}",
+		"camerasStoppedEarly": "Arrêtées prématurément : {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/it/launch.json b/src/i18n/locales/it/launch.json
index 2290d693a..e9f7fa36b 100644
--- a/src/i18n/locales/it/launch.json
+++ b/src/i18n/locales/it/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "Fotocamere aggiuntive",
 		"additionalCamerasHint": "Solo con la registrazione nativa di Windows",
 		"camerasNotRecorded": "Non registrate: {{names}}",
+		"camerasStoppedEarly": "Interrotte in anticipo: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/ja-JP/launch.json b/src/i18n/locales/ja-JP/launch.json
index 4d7fcf3ce..7c28f6731 100644
--- a/src/i18n/locales/ja-JP/launch.json
+++ b/src/i18n/locales/ja-JP/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "追加のカメラ",
 		"additionalCamerasHint": "Windows のネイティブ録画でのみ使用できます",
 		"camerasNotRecorded": "録画されませんでした: {{names}}",
+		"camerasStoppedEarly": "途中で停止しました: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/ko-KR/launch.json b/src/i18n/locales/ko-KR/launch.json
index 641fb53d8..706dab4bc 100644
--- a/src/i18n/locales/ko-KR/launch.json
+++ b/src/i18n/locales/ko-KR/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "추가 카메라",
 		"additionalCamerasHint": "Windows 기본 녹화에서만 사용할 수 있습니다",
 		"camerasNotRecorded": "녹화되지 않음: {{names}}",
+		"camerasStoppedEarly": "중간에 중지됨: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/pt-BR/launch.json b/src/i18n/locales/pt-BR/launch.json
index 276d494e0..eabcbebba 100644
--- a/src/i18n/locales/pt-BR/launch.json
+++ b/src/i18n/locales/pt-BR/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "Câmeras adicionais",
 		"additionalCamerasHint": "Somente com a gravação nativa do Windows",
 		"camerasNotRecorded": "Não gravadas: {{names}}",
+		"camerasStoppedEarly": "Pararam antes do fim: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/ru/launch.json b/src/i18n/locales/ru/launch.json
index 1d99fd9b5..dbbb750b1 100644
--- a/src/i18n/locales/ru/launch.json
+++ b/src/i18n/locales/ru/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "Дополнительные камеры",
 		"additionalCamerasHint": "Только при встроенной записи в Windows",
 		"camerasNotRecorded": "Не записаны: {{names}}",
+		"camerasStoppedEarly": "Остановились раньше времени: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/tr/launch.json b/src/i18n/locales/tr/launch.json
index 22c00b419..b8f3309d1 100644
--- a/src/i18n/locales/tr/launch.json
+++ b/src/i18n/locales/tr/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "Ek kameralar",
 		"additionalCamerasHint": "Yalnızca yerel Windows kaydıyla",
 		"camerasNotRecorded": "Kaydedilmedi: {{names}}",
+		"camerasStoppedEarly": "Erken durdu: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/vi/launch.json b/src/i18n/locales/vi/launch.json
index 0416dce15..ae776c2d0 100644
--- a/src/i18n/locales/vi/launch.json
+++ b/src/i18n/locales/vi/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "Camera bổ sung",
 		"additionalCamerasHint": "Chỉ với tính năng quay gốc của Windows",
 		"camerasNotRecorded": "Không được ghi: {{names}}",
+		"camerasStoppedEarly": "Đã dừng sớm: {{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/zh-CN/launch.json b/src/i18n/locales/zh-CN/launch.json
index 03cb0f418..9c2cbeae3 100644
--- a/src/i18n/locales/zh-CN/launch.json
+++ b/src/i18n/locales/zh-CN/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "附加摄像头",
 		"additionalCamerasHint": "仅支持 Windows 原生录制",
 		"camerasNotRecorded": "未录制：{{names}}",
+		"camerasStoppedEarly": "提前停止：{{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"
diff --git a/src/i18n/locales/zh-TW/launch.json b/src/i18n/locales/zh-TW/launch.json
index 97bb58696..f9c72b322 100644
--- a/src/i18n/locales/zh-TW/launch.json
+++ b/src/i18n/locales/zh-TW/launch.json
@@ -51,6 +51,7 @@
 		"additionalCameras": "額外攝影機",
 		"additionalCamerasHint": "僅限 Windows 原生錄影",
 		"camerasNotRecorded": "未錄製：{{names}}",
+		"camerasStoppedEarly": "提前停止：{{names}}",
 		"quality1080p": "1080p",
 		"quality1440p": "1440p",
 		"quality2160p": "4K"

From 20f7044ba937b91428998a92406dc567f07db0bc Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sun, 4 Oct 2026 13:20:15 +0200
Subject: [PATCH 17/22] docs(e2e): identical cameras and screen pacing with
 several cameras

The checklist now notes that with several identical cameras plugged in the
recorded ones follow Windows' enumeration order, adds a 1-vs-2-camera screen
pacing comparison at 4K (#945) and a stopped-early check. The helper README
says the camera index counts after entries without camPath are skipped, and
the extras-need-camera-1 assumption (R6) is noted where links drop them.
---
 electron/ipc/handlers.ts                                | 3 +++
 electron/media/mediaLinksRegistry.ts                    | 3 +++
 electron/native/README.md                               | 2 +-
 technical-documentation/testing/manual-e2e-checklist.md | 3 +++
 4 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index f1cbfe31f..8270c69da 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -4960,6 +4960,9 @@ export function registerIpcHandlers(
 					return { success: false, error: "Video path has not been approved" };
 				}
 				const resolution = await resolveMediaLinksForVideo(normalized);
+				// Additional cameras are only returned alongside camera 1. That relies
+				// on R6 (extras are recorded only while camera 1 is on), so extras
+				// without camera 1 means camera 1's file came out empty.
 				if (!resolution.webcamVideoPath) {
 					return { success: false, error: "No camera attached to this recording" };
 				}
diff --git a/electron/media/mediaLinksRegistry.ts b/electron/media/mediaLinksRegistry.ts
index 69d119d51..56bd7d57f 100644
--- a/electron/media/mediaLinksRegistry.ts
+++ b/electron/media/mediaLinksRegistry.ts
@@ -243,6 +243,9 @@ export async function registerMediaLinks(
 	videoPath: string,
 	links: MediaLinksToRegister,
 ): Promise<void> {
+	// Extras alone register nothing. That relies on R6: additional cameras are
+	// recorded only while camera 1 is on, so a take with extras but no camera 1
+	// is one whose camera 1 file came out empty — a rare loss accepted here.
 	if (!links.webcamVideoPath && !links.cursorTelemetryPath) return;
 	const { additionalWebcams: rawAdditionalWebcams, ...linksWithoutAdditional } = links;
 	const additionalWebcams = normalizeAdditionalWebcams(rawAdditionalWebcams);
diff --git a/electron/native/README.md b/electron/native/README.md
index 931a91471..d9856d052 100644
--- a/electron/native/README.md
+++ b/electron/native/README.md
@@ -94,7 +94,7 @@ Several cameras: a `webcams` list records up to four cameras, each into its own
 ]
 ```
 
-Every per-camera event carries the camera's `index` in that list: `webcam-format` (`{"event":"webcam-format","schemaVersion":2,"index":0,"width":…,"height":…,"fps":…,"deviceName":"…"}`) for each camera that opened, and `{"event":"warning","code":"webcam-unavailable","index":1,"deviceName":"…","message":"…"}` for each that did not (`code` comes before `index` so older substring readers still match). A camera that cannot be opened, or whose encoder or capture will not start (the message says which), is dropped and the rest of the take goes on; a camera whose encoder rejects a sample mid-take is disabled on its own, without stopping the screen or the other cameras. `recording-stopped` keeps `webcamPath` (camera 0, when it recorded) and adds `webcamPaths`, the files of every camera still recording at stop, in index order — an empty list when every camera that wrote a file of its own was disabled mid-take, so a reader can tell "stopped early" from an older helper that never sends the key. Both are printed before the camera files are finalized (see the stop sequence), so a camera whose finalize fails is reported on stderr and by a non-zero exit, not removed from the list. Each camera finalizes in its own `[stop-timing]` step, `webcam-encoder-finalize-<index>`.
+Every per-camera event carries the camera's `index`, its position in the list after entries without `camPath` have been skipped: `webcam-format` (`{"event":"webcam-format","schemaVersion":2,"index":0,"width":…,"height":…,"fps":…,"deviceName":"…"}`) for each camera that opened, and `{"event":"warning","code":"webcam-unavailable","index":1,"deviceName":"…","message":"…"}` for each that did not (`code` comes before `index` so older substring readers still match). A camera that cannot be opened, or whose encoder or capture will not start (the message says which), is dropped and the rest of the take goes on; a camera whose encoder rejects a sample mid-take is disabled on its own, without stopping the screen or the other cameras. `recording-stopped` keeps `webcamPath` (camera 0, when it recorded) and adds `webcamPaths`, the files of every camera still recording at stop, in index order — an empty list when every camera that wrote a file of its own was disabled mid-take, so a reader can tell "stopped early" from an older helper that never sends the key. Both are printed before the camera files are finalized (see the stop sequence), so a camera whose finalize fails is reported on stderr and by a non-zero exit, not removed from the list. Each camera finalizes in its own `[stop-timing]` step, `webcam-encoder-finalize-<index>`.
 
 Container: recordings are written as fragmented MP4 (`MFCreateFMPEG4MediaSink` + `MFCreateSinkWriterFromMediaSink`, `MF_MPEG4SINK_MIN_FRAGMENT_DURATION` = 1s) rather than plain MP4. A plain MP4 has no index until `IMFSinkWriter::Finalize()` writes `moov` at the very end, so when the shutdown watchdog force-exits a wedged helper the file on disk holds every frame and no way to read them — that is why issues #252 / #292 / #327 cost the whole recording rather than the frozen tail of it. A fragmented MP4 writes its index up front and its samples in self-describing `moof`+`mdat` pairs, so the same kill leaves a file that plays up to the last complete fragment. This does not fix the freeze; it removes the data loss the freeze causes. Because the fragmented sink needs both output media types at construction, the sink writer is built from a media sink instead of from a URL, and the helper reads the video/audio stream positions back off the sink rather than assuming them. If any of that is unavailable on a machine, the helper retries with the plain container and says so — `container` in the `encoder-selection` event is `fragmented-mp4` or `mp4`, and it reports what was used, not what was asked for.
 
diff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.md
index ec4a4fd09..3fb4cc255 100644
--- a/technical-documentation/testing/manual-e2e-checklist.md
+++ b/technical-documentation/testing/manual-e2e-checklist.md
@@ -226,8 +226,11 @@ Up to four cameras record into one take on the native Windows path: camera 1 as
 - [ ] Several cameras (Windows). Pick a second camera under *Additional cameras*, record about 10 s and clap in front of both cameras. Both camera files exist next to the recording (`-webcam.mp4`, `-webcam-2.mp4`) and both play. The clap lands at the same time in both and against the screen. The editor shows camera 1 as before. After saving and reopening, the project still lists both cameras.
 - [ ] Order of the runs: start with two cameras of different names (Logitech Brio plus C920), then two identical Brios. Record at 1080p first, and at 4K afterwards as a load test: two 4K cameras on one USB controller may lack the bandwidth, so a camera that drops out there is a finding about the controller first and the app second. Log the controller layout next to the result.
 - [ ] With two identical Brios, which physical Brio becomes camera 1 follows Windows' enumeration order, not the HUD choice or its preview. A swap against the preview is a known limitation, not a defect. Wave a hand into one camera at a time to tell the files apart, and note which is which.
+- [ ] Identical cameras are matched by name, so with several of one model plugged in, *which* of them get recorded also follows Windows' enumeration order, not the HUD picks: with three Brios attached and two picked, the third may be recorded instead of a picked one. Plug in only the identical cameras you want to record, and note any mismatch as this known limitation.
+- [ ] **[4K camera]** Screen pacing with several cameras. Screen pacing is a known weak spot (#945), and a pacing regression under camera load is easy to misread as a USB problem. Record the same 20 s screen scene twice at 4K camera quality, once with one camera and once with two, and compare the screen file of each: `ffprobe -v error -select_streams v:0 -count_frames -show_entries stream=nb_read_frames,avg_frame_rate <screen>.mp4`, plus the helper's `[pacing] frames=<n> elapsed_ms=<ms>` line from the diagnostics (and `[frame-drops]` on the GPU input path). Frames over elapsed time should match the chosen screen rate in both runs; the helper does not log individual missed ticks, so a shortfall shows only there. A two-camera run whose screen falls clearly short of the one-camera run is a pacing finding for the helper, not a camera or controller one, whatever the camera files look like. Log both numbers.
 - [ ] Read the helper output (`Save diagnostics`, or `(Get-Content diag.json -Raw | ConvertFrom-Json).helperOutput.windows -split "`n" | Select-String "webcam"`). Camera 2's `Native webcam candidate` lines list the second Brio, and neither the IR or any other interface of the first Brio nor a candidate marked `already recording in this take`. Each camera prints its own `webcam-format` event with its `index`, and `recording-stopped` carries both paths in `webcamPaths`.
 - [ ] A camera that cannot be opened or records nothing is named in a "Not recorded: …" notice after the take, and the take is kept with the cameras that worked. Provoke it by unplugging the second camera, or holding it open in another app, just before *Start recording*, and check the helper output for `{"event":"warning","code":"webcam-unavailable","index":1,…}`. Camera 1 and the screen are unaffected.
+- [ ] A camera the helper disables mid-take (its log says `ERROR: Failed to capture a sample for camera <n>; disabling it`, or `submit`) keeps its partial file in the take and is named in a "Stopped early: …" notice after the take; `recording-stopped.webcamPaths` lists only the cameras still recording at stop. Try unplugging the second camera halfway through; if that leaves no such line, the encoder never failed and there is nothing to check, so log `skipped: could not provoke a mid-take camera failure`.
 - [ ] With the first camera turned off in the HUD, record again and confirm no additional camera is recorded (additional cameras follow camera 1).
 - [ ] Probe every file: `ffprobe -show_entries format=duration` of each camera file is within 0.2 s of the screen file's.
 

From 38d838b9a596d7794de71a753291d41a3b163b5f Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Mon, 5 Oct 2026 08:27:55 +0200
Subject: [PATCH 18/22] docs(e2e): log the first real two-camera run on Windows
 on ARM

---
 technical-documentation/testing/manual-e2e-checklist.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.md
index 3fb4cc255..479a0910e 100644
--- a/technical-documentation/testing/manual-e2e-checklist.md
+++ b/technical-documentation/testing/manual-e2e-checklist.md
@@ -870,3 +870,4 @@ On macOS 15.2+ it opens at launch, until it has been closed once, while one of i
 | 2026-10-03 | installed `v2.0.0-rc.13`, CI-built DMG `Openscreen-macOS-Apple-Silicon-2.0.0-rc.13.dmg` from the GitHub Release (tag `018d22ab`), installed over rc.12, `spctl`: accepted, Notarized Developer ID (M4LK7C6S84), About reports `2.0.0-rc.13` | macOS 26.5 (25F71), Mac mini M1, 3840×2160, no camera, no microphone | Partial, no defect | **Scoped to the app changes between rc.8 and rc.13, on macOS**: the Windows row above covers the same diff on Windows and leaves out #967, c2a8559e and macOS, which this row takes. Real OS mouse and keyboard input through computer-use (screenshots worked on this Mac); Apple's picker is owned by Control Centre and cannot be granted, so the operator clicked *Share Entire Screen* for each take. **c2a8559e (HUD kept out of takes after the editor round trip):** take 1 picked from the HUD's record button (`excludedWindowIds: [582]`), stop, editor, Record mode showed the source as *Choose what to record*, *Start recording* reopened Apple's picker instead of reusing the pick, take 2 recorded with `excludedWindowIds: [639]`; frames extracted from both files (28:26 and 13:04) show no HUD where it sat. **#967 (no camera on this Mac):** with `camEnabled: true` and no camera identity in `recording-settings.json`, launch rewrote it to `false` and the HUD showed the camera off; same with a stale identity (`camDeviceId` + `camDeviceName` of an unplugged camera); clicking the toggle keeps it off with the "Camera access is blocked" toast; Record mode reads *Camera Off*. **#961:** closing the editor after take 2 (countdown overlay, Record mode handover) left 0 processes; so did closing it after a long editor session (eight project opens through the native panel, transcriptions, Media mode, an export, the export dialog's save panel cancelled). **#966:** with *Add zoom* bound to X in `shortcuts.json`, the empty zoom lane reads "Press X to add zoom", and "Appuyez sur X pour ajouter un zoom" / "Drücke X, …" in French and German. **Wordmark menu (3bee2d25):** French and German, every row on one line, "2.0.0-rc.13" in one piece. **#960 (b834416c):** project A with captions → project B → A again: captions show at once at 0:06.4, 0:10.2 and 1:05.2 without touching *Show captions* (0:05.3 shows none, a 4.77 to 5.57 s silence in the saved words). **Preview:** playback from 0:12 to the end across four transcript silence cuts, a 2× and a 16× region: picture and captions follow, the readout advances with the edit, stops at 1:06.2; no stall seen, 8 `[pipeline] décodage` opens for one seek and four cuts (consistent with a preload per cut; not compared with rc.12). **227b9b84 / 83fbcecc:** a two-clip project whose first clip is a file with 8 s of video and 10 s of audio (no camera): seeking from clip 2 to 0:09.5 shows clip 1's last frame, the same as 0:07.7, no stderr. A video-only file plays with its picture (e73097c8). **#968:** project whose first asset is `chmod 000`: `MediaUnreadableError … Permission denied` in the main log, clip 2 still transcribed, the asset card shows "Transcription failed" and "Couldn't read this media's audio. Make sure OpenScreen can access the folder it's in, then regenerate." without the IPC wrapper; after `chmod 644`, *Regenerate* runs again (not persisted as no-audio). **Metal compositor (8caaa20d, dd5e914b, 0624c148, 2fb994eb):** laptop frame, 3D cursor, click impact, image background blurred 53 %, Aurora, captions; MP4 1080p60 export of 3374 frames, video and audio 56.23 s against 56.21 s computed (66.154 s minus 5.09 s of cuts minus the 2× and 16× gains), full decode clean; extracted frames show the laptop with its shadow, the blurred background, the 3D cursor with its shadow, rounded screen corners and captions. During playback the preview followed image → image, blur 52 → 1 %, image → colour and back. **Also seen:** the playhead keeps its time when another project is opened (0:41.0 from A shown in B and C). With a hand-written `camDeviceName` and a null `camDeviceId`, the HUD keeps the camera on and the file at `true` (`useCameraHudSync` compares the empty selection with the empty id and returns early); the app always writes both together, so this state is artificial. Out of scope: a 10 s extract with speech under loud video sound transcribes as no speech in Auto (detected `en`, p 0.35) and as "*Musique*" in French. **Not run:** webcam and microphone (none on this Mac), so the Windows row's webcam-past-the-end defect cannot be checked here; click impact not confirmed (the fixture's cursor sidecar has no clicks, and none was identified around the nine clicks of take 2 at preview scale); Aurora motion on a plain colour; the 4× preview lag of the rc.12 row (not re-measured: this pass played 2× and 16× regions without timing the lag); `Esc`; tray; GIF; A/B against rc.12; Gatekeeper (the DMG came through `gh`, no quarantine flag); Intel. |
 | 2026-10-03 | installed `v2.0.0-rc.15` (build run 37124242835, tag `ccd8b449`, NSIS sha512 matched `latest.yml`), installed over rc.12 for all users, About reports `2.0.0-rc.15` (`win32 x64 · nsis`, Electron 41.2.1, Chromium 146.0.7680.188, Node 24.14.1). `v2.0.0` was promoted from this candidate during the pass and differs from it only by the version bump (`eff86dcb`), so the results hold for the stable code | Windows 11 Home 26200, 1920×1080 @ 125 %, AMD Ryzen 5 7520U / Radeon iGPU, built-in USB2.0 HD UVC WebCam (best mode 1280×720@30), Microphone Array (AMD) | Partial — 6 defects | **Whole-file pass on Windows.** Real OS mouse and keyboard input throughout. Computer-use screenshots came back grey again, so the app was observed through `PrintWindow` on its own windows and DOM reads over CDP, and every picture and sound claim below was measured on the file with ffprobe/ffmpeg. **Defects:** (1) #1004, HUD drag at 125 %: the HUD window grows about 1.5 px per drag step (1180×882 → 1232×935 over ~43 steps) and the bar jumps by half the growth on release; after a long drag down the bar sat partly under the taskbar (centre y 1042, work area ends at 1032). (2) #1005, *Edit clip*: Reset, Cancel and Apply sit inside the scrolling body. In a 1240×1000 window (794 css px tall) the card is clipped above Apply, and a click where Apply should be lands on the backdrop, closing the dialog and discarding the edit. It fits when the window is maximized. (3) #1006, the rail's "Choose a clip to edit" menu renders under the timeline toolbar: Clip 2 and Clip 3 are covered (`elementFromPoint` returns `_tlToolbar`) and clicks on them do nothing. (4) #1007, a clip duplicated with Ctrl+C / Ctrl+V does not carry its anchored zoom or Full Camera region: `duplicateClip` in `src/lib/ai-edition/document/timeline.ts` copies only `trimRanges`. (5) #1008, zoom repel across a clip boundary: a zoom dragged into a neighbour that ends at its clip's end jumps past it into the next clip, shrinking from 12.97 to 8.23 s and leaving a zero-length fragment on the first clip. Ctrl+Z restores it. (6) #1009, the wordmark menu does not close on a click on the bare top bar. The header is a `-webkit-app-region: drag` area, which never delivers the document `mousedown` that `AppMenu` listens for. It does close on the preview, on a top-bar button and on the wordmark. **Passed: HUD and capture.** One HUD, `[content-protection] OFF` logged; horizontal ↔ vertical layout; every tooltip, idle and recording, beside or above the bar and unclipped; language menu (15 locales); camera and microphone toggles in one click; device settings: three inputs, level meter, live camera preview, camera quality row (1080p persisted across a relaunch; hand-edited 720p and an absent key both read 4K). Hide bar, then the tray overflow icon brings the HUD back; Quit leaves 0 processes; a second launch exits 0. With no source the record tooltip reads "Choose a screen or window to record" and one click opens the picker, then starts. While recording: source button disabled, toggles `aria-disabled`, gear inert, tray tooltip "Recording: Tout l'écran". Pause freezes the timer and resume advances it; restart starts a new helper and deletes the first file; cancel deletes the file and opens no editor. Stop opens the editor with "Recording added to a new project". Screen H.264 High bt709 1920×1080; AAC 48 kHz; webcam 1280×720 ~30 fps at 8 Mbit/s, the camera's best mode, not upscaled, matching `webcamFormat`. Microphone-only, system-audio-only and all-off takes behave; window source 1270×668, non-black; an odd 1001×601 window gives an even 992×596 file; a context menu inside the window is recorded and cut at its edge. Without the flag the HUD and an open Notes window are absent from the take. Record mode: rows, live camera preview, microphone meter, device switch, source modal with badge, *Start recording* hands over to the HUD; auto-zoom on gives one merged zoom over three clicks, off gives none, and the setting persists; editable cursor off hides the auto-zoom row and the Cursor facet; *Hide desktop icons* shows a bare wallpaper and restores the icons after. **Passed: editor.** Rename, Saved dot, tabs, chat panel toggle, tooltips with key chips, dividers; play, pause, seek playing and paused, ±1 frame arrows, stop at end; ruler click and drag, navigator narrow and pan, labels without collision, playhead within 0.5 px; Ctrl+S toast with a stable top bar. Clips: media card drag and *Add to timeline*, reorder, Edit clip grips, 1:1 crop held through a corner drag, Free, Cancel, pencil, delete. Trim, zoom (levels, custom, out-of-range message, focus drag, 3D modes), speed (presets, custom, 16× cap message, playback at 16×), annotation (text, sizes, plates, palette, Typewriter, image, arrow, blur mosaic and smooth, oval, clamped, dragged into padding); Ctrl+D, Ctrl+Z, Ctrl+Shift+Z. Modifiers inside a trim fire on the parked frame. Copy and paste of zoom, annotation and trim with their toasts and properties; an empty copy is a no-op; deleting a clip removes its modifiers; Edit clip clamps them; a Full Camera region across a junction splits and merges as clips move. Imported music: fragments across a junction with `offsetMs`, −18 dB and 1 s fades, gain, *Reset audio*; voiceover lands at the playhead. Transcript: clip order, silences, monotonic word seeks, live cue, Backspace skip and restore, silence trim; captions in four styles and six anchors; French translation with a *Display* row, and deleting it leaves the words untouched; typing in the packaged gate does nothing; a double-click correction survives *Regenerate as English* (model reused); 101 languages, detected language on the card. Composition: colour, gradient and one-colour gradient, wallpaper, animations move during playback only (21–23 distinct frames in 3 s, None 1), blur, 9:16 with Whole and Follow cursor, Auto padding with even borders, shadows, four frame styles in both themes. Camera layout: four presets, mirror, square, size (default 40, max 60), roundness, positions; background Cutout, Blur with an intensity slider, Custom image and colour, and the custom-colour mask reaches a 720p export; webcam crop corner zoom (124 %) and frame move. Audio facet: +6.5 dB raises the export from −17.2 to −12.7 LUFS with the peak held at −1.3 dBFS; reset returns 0 dB. Cursor facet: hide, style, size (to 5.8 of 6) and 3D cursor all show in the preview. Depth of field appears once a zoom has a 3D preset and changes the preview. Wordmark menu: rows as listed, About row version, arrows wrap both ways; Keyboard Shortcuts as one dialog: Z → Q changes the lane hint, Q adds a zoom, Z does nothing, reset restores Z; Ctrl+O; AI settings as one dialog; light and dark themes, dialogs included; French UI with one-line menu rows (#969), back to English; About lists the versions and channel, and Copy puts the same block on the clipboard; the HUD panel's version row and Check for Updates ("Checking…", disabled, the same dialog as the menu, re-enabled after). AI chat (deepseek): "add one zoom at 2x from 5 s to 8 s" lands as 5–8 s at 2.20× with the reason given, is undone by one Ctrl+Z and redone. Closing the editor quits the app and writes `editor-window.json` (`maximized: false`); after a relaunch the last project's settings and the main project's two clips, crop, regions, music, voiceover and captions are as left, and a paste before any copy changes nothing. A schema-4 project from July opens, migrates to schema 8, and keeps its clip, seven zooms and annotation. **Export:** MP4 1080p30 of the two-clip project, 10288 frames, audio and video within one frame, −16.0 LUFS and −1.4 dBTP, annotation upright, caption plate at x = 108 for a 10 % inset, Full Camera where mapped, music ducked about 10 dB under speech with fades at the track's own edges, muted track absent, voiceover not stretched by a 2× region. GIF 25 fps: cancel removes the partial file and leaves the existing destination untouched; the full render (~127 s, #952) gives 434 frames, infinite loop, consistent in ffmpeg and GDI+. **Also seen:** a take with a ~4 s pause had audio 1.09 s past its video, against 0.02–0.17 s without a pause; three dedicated paused takes gave 0.40, 0.15 and 0.03 s. The export ends each clip at its last video frame (10288 frames against the 10320 the progress counted), so the timeline and the export disagree by that tail. The editor reopens 4 px taller than it closed at 125 %. **Not run:** the A/V offset across a pause measured directly (the flash-and-beep rig never painted on the captured desktop), the HUD with no camera (needs the camera disabled in Windows), tray right-click menus (Update Settings, Stop Recording, Save Diagnostics: Explorer is granted click-only), the Alt Help menu (an Alt tap showed nothing, inconclusive), Ctrl/Shift+wheel on the timeline, cursor auto-hide, smoothing, motion blur and click effects, annotation animations other than Typewriter, Depth of field in an export, chat rewind, history and Smart cuts, a software-encoder take, the crackle and hole scan, multiple displays, 4K and 1440p cameras, 150 % DPI, macOS and Linux. |
 | 2026-10-04 | dev `feat/multi-camera-recording` at `212c07f7` (feature head `23ea0751` + the HUD probe lint fix); `wgc-capture.exe` rebuilt from this tree by `npm run build:native:win` | Windows 11 on ARM64 (Snapdragon X Elite), one built-in camera (`AI Front Camera`), driven without computer-use | **Partial — the two-webcam run on site is outstanding; sub-project not complete until logged** | **Ran:** unit suite (`npm run test`, 304 of 305 files, the one failure `LeftPanel.copyMessage.test.tsx` passed alone, a load flake), both `tsc`, lint (0 errors, 26 warnings, the base count), `i18n:check`; the helper's native unit tests (`node scripts/build-windows-wgc-helper.mjs`, all pass); helper smoke runs `npm run test:wgc-helper:win`, `-- --webcam` and `-- --webcam --missing-second-webcam` (index 1 dropped and named, camera 1 kept); a direct helper run listing the one camera twice: camera 1 recorded, camera 2 dropped with `webcam-unavailable` index 1 and "already recording in this take", `webcamPaths` held one file, exit 0, camera file 4.81 s against the screen's 4.80 s. **Not run:** the app click-through (HUD *Additional cameras*, editor, save and reopen, the session manifest's `additionalWebcams`, the "Not recorded" notice): no computer-use here and only one camera. **Not covered at all:** two real cameras recording together, identical-name Brios, 1080p and 4K load, clap sync, macOS and Linux. |
+| 2026-10-05 | dev `feat/multi-camera-recording` at `86d49475`; `wgc-capture.exe` from `electron/native/wgc-capture/build` (4 Oct 13:05, `findstr` hit the fix-wave string *Could not remove the dropped camera file* and the control `encoder-selection`); `compositor_view.node` built from this tree by `npm run build:native:compositor` (ARM64) and loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE` next to the vendored win32-arm64 ffmpeg | Windows 11 on ARM64 (Snapdragon X Elite), **Logitech BRIO** (USB) + built-in `AI Front Camera`, 2560×1440 display | **Partial — two real cameras pass; Brio + C920, two identical Brios, 4K load and a mid-take camera loss not run yet** | *Helper:* Brio as camera 1 + built-in as camera 2 at 1080p30, 38 s take with three claps — both camera files 1146 frames / 38.19 s, screen 38.20 s at a steady 30 fps (`[pacing] frames=1146 elapsed_ms=38201`), camera 2 skipped the claimed Brio (`already recording in this take`), `webcamPaths` listed both. Clap sync by per-frame motion cross-correlation: 0 frames over the whole take, ≤ 1 frame (33 ms) per 3 s window; an 8-frame strip of the strongest clap shows the hands meeting and opening in the same frames on both. *App (HUD driven by the user):* Brio as camera 1, built-in ticked under *Additional cameras* — three files written, session `additionalWebcams` with label `AI Front Camera`, no *Not recorded* notice; Studio shows screen + camera 1 as before; the project holds `additionalCameraTracks` (1920×1080, offset 0, label) and keeps it after reopen, an edit and save. | The editor cannot select camera 2 yet — by design, sub-projects 2/3. First dev launch had no `compositor_view.node` in the worktree (blank Studio: `native addon not present`) — environment, not product. |

From b4d10be032250cb5262a22d129ba103b91c95c23 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Mon, 5 Oct 2026 08:49:53 +0200
Subject: [PATCH 19/22] fix(wgc): stop and report a camera that is unplugged
 mid-take

A failed ReadSample was counted and retried forever, so an unplugged camera
kept its file running to the end on its last picture and stayed in
webcamPaths. The Media Foundation capture now latches lost on a device
invalidated or hardware start failure, on end of stream during the take, or
after a second of consecutive read failures; the DirectShow fallback latches
it on EC_DEVICE_LOST (removal), EC_ERRORABORT or EC_STREAM_ERROR_STOPPED. The
writer loop disables a lost camera like any mid-take failure, so its file ends
at the loss and the app names it as stopped early.
---
 electron/native/README.md                     |  2 +-
 electron/native/wgc-capture/CMakeLists.txt    | 16 ++++++++
 .../wgc-capture/src/dshow_webcam_capture.cpp  | 40 ++++++++++++++++++
 .../wgc-capture/src/dshow_webcam_capture.h    |  8 ++++
 electron/native/wgc-capture/src/main.cpp      | 15 +++++++
 .../native/wgc-capture/src/webcam_capture.cpp | 35 ++++++++++++++++
 .../native/wgc-capture/src/webcam_capture.h   | 10 +++++
 .../native/wgc-capture/src/webcam_loss.cpp    | 28 +++++++++++++
 electron/native/wgc-capture/src/webcam_loss.h | 34 +++++++++++++++
 .../wgc-capture/src/webcam_loss_test.cpp      | 41 +++++++++++++++++++
 scripts/build-windows-wgc-helper.mjs          |  8 ++++
 11 files changed, 236 insertions(+), 1 deletion(-)
 create mode 100644 electron/native/wgc-capture/src/webcam_loss.cpp
 create mode 100644 electron/native/wgc-capture/src/webcam_loss.h
 create mode 100644 electron/native/wgc-capture/src/webcam_loss_test.cpp

diff --git a/electron/native/README.md b/electron/native/README.md
index d9856d052..a9c6f8b83 100644
--- a/electron/native/README.md
+++ b/electron/native/README.md
@@ -94,7 +94,7 @@ Several cameras: a `webcams` list records up to four cameras, each into its own
 ]
 ```
 
-Every per-camera event carries the camera's `index`, its position in the list after entries without `camPath` have been skipped: `webcam-format` (`{"event":"webcam-format","schemaVersion":2,"index":0,"width":…,"height":…,"fps":…,"deviceName":"…"}`) for each camera that opened, and `{"event":"warning","code":"webcam-unavailable","index":1,"deviceName":"…","message":"…"}` for each that did not (`code` comes before `index` so older substring readers still match). A camera that cannot be opened, or whose encoder or capture will not start (the message says which), is dropped and the rest of the take goes on; a camera whose encoder rejects a sample mid-take is disabled on its own, without stopping the screen or the other cameras. `recording-stopped` keeps `webcamPath` (camera 0, when it recorded) and adds `webcamPaths`, the files of every camera still recording at stop, in index order — an empty list when every camera that wrote a file of its own was disabled mid-take, so a reader can tell "stopped early" from an older helper that never sends the key. Both are printed before the camera files are finalized (see the stop sequence), so a camera whose finalize fails is reported on stderr and by a non-zero exit, not removed from the list. Each camera finalizes in its own `[stop-timing]` step, `webcam-encoder-finalize-<index>`.
+Every per-camera event carries the camera's `index`, its position in the list after entries without `camPath` have been skipped: `webcam-format` (`{"event":"webcam-format","schemaVersion":2,"index":0,"width":…,"height":…,"fps":…,"deviceName":"…"}`) for each camera that opened, and `{"event":"warning","code":"webcam-unavailable","index":1,"deviceName":"…","message":"…"}` for each that did not (`code` comes before `index` so older substring readers still match). A camera that cannot be opened, or whose encoder or capture will not start (the message says which), is dropped and the rest of the take goes on; a camera whose encoder rejects a sample mid-take is disabled on its own, without stopping the screen or the other cameras. A camera unplugged mid-take (or whose reads keep failing for a second) is disabled the same way: its file ends at the loss, is still finalized at stop, and is left out of `webcamPaths`. `recording-stopped` keeps `webcamPath` (camera 0, when it recorded) and adds `webcamPaths`, the files of every camera still recording at stop, in index order — an empty list when every camera that wrote a file of its own was disabled mid-take, so a reader can tell "stopped early" from an older helper that never sends the key. Both are printed before the camera files are finalized (see the stop sequence), so a camera whose finalize fails is reported on stderr and by a non-zero exit, not removed from the list. Each camera finalizes in its own `[stop-timing]` step, `webcam-encoder-finalize-<index>`.
 
 Container: recordings are written as fragmented MP4 (`MFCreateFMPEG4MediaSink` + `MFCreateSinkWriterFromMediaSink`, `MF_MPEG4SINK_MIN_FRAGMENT_DURATION` = 1s) rather than plain MP4. A plain MP4 has no index until `IMFSinkWriter::Finalize()` writes `moov` at the very end, so when the shutdown watchdog force-exits a wedged helper the file on disk holds every frame and no way to read them — that is why issues #252 / #292 / #327 cost the whole recording rather than the frozen tail of it. A fragmented MP4 writes its index up front and its samples in self-describing `moof`+`mdat` pairs, so the same kill leaves a file that plays up to the last complete fragment. This does not fix the freeze; it removes the data loss the freeze causes. Because the fragmented sink needs both output media types at construction, the sink writer is built from a media sink instead of from a URL, and the helper reads the video/audio stream positions back off the sink rather than assuming them. If any of that is unavailable on a machine, the helper retries with the plain container and says so — `container` in the `encoder-selection` event is `fragmented-mp4` or `mp4`, and it reports what was used, not what was asked for.
 
diff --git a/electron/native/wgc-capture/CMakeLists.txt b/electron/native/wgc-capture/CMakeLists.txt
index 870f4003a..009a04677 100644
--- a/electron/native/wgc-capture/CMakeLists.txt
+++ b/electron/native/wgc-capture/CMakeLists.txt
@@ -62,6 +62,8 @@ add_executable(wgc-capture
   src/wasapi_render_keepalive.cpp
   src/wasapi_render_keepalive.h
   src/webcam_capture.cpp
+  src/webcam_loss.cpp
+  src/webcam_loss.h
   src/webcam_format.cpp
   src/webcam_format.h
   src/webcam_config.cpp
@@ -234,3 +236,17 @@ target_compile_definitions(device_selection_test PRIVATE
 )
 
 target_compile_options(device_selection_test PRIVATE /EHsc /W4 /utf-8)
+
+add_executable(webcam_loss_test
+  src/webcam_loss.cpp
+  src/webcam_loss.h
+  src/webcam_loss_test.cpp
+)
+
+target_compile_definitions(webcam_loss_test PRIVATE
+  NOMINMAX
+  WIN32_LEAN_AND_MEAN
+  _WIN32_WINNT=0x0A00
+)
+
+target_compile_options(webcam_loss_test PRIVATE /EHsc /W4 /utf-8)
diff --git a/electron/native/wgc-capture/src/dshow_webcam_capture.cpp b/electron/native/wgc-capture/src/dshow_webcam_capture.cpp
index c7773505a..837f70f68 100644
--- a/electron/native/wgc-capture/src/dshow_webcam_capture.cpp
+++ b/electron/native/wgc-capture/src/dshow_webcam_capture.cpp
@@ -2,6 +2,7 @@
 
 #include "realtime_scheduling.h"
 #include "webcam_format.h"
+#include "webcam_loss.h"
 
 #include <initguid.h>
 #include <dshow.h>
@@ -176,6 +177,8 @@ struct DirectShowWebcamCapture::Impl {
     Microsoft::WRL::ComPtr<ISampleGrabber> sampleGrabber;
     Microsoft::WRL::ComPtr<IBaseFilter> nullRenderer;
     Microsoft::WRL::ComPtr<IMediaControl> mediaControl;
+    /** Where the graph says the device left; optional, see captureLoop. */
+    Microsoft::WRL::ComPtr<IMediaEventEx> mediaEvent;
     bool comInitialized = false;
     bool running = false;
 };
@@ -275,6 +278,7 @@ bool DirectShowWebcamCapture::buildGraph(
     // Every attempt starts from empty filters. A RenderStream that fails can
     // leave pins connected behind it, and retrying on top of that half-built
     // graph is how you get a second failure that says nothing about the format.
+    impl_->mediaEvent.Reset();
     impl_->mediaControl.Reset();
     impl_->nullRenderer.Reset();
     impl_->sampleGrabber.Reset();
@@ -434,6 +438,10 @@ bool DirectShowWebcamCapture::initialize(
     if (!succeeded(impl_->graph.As(&impl_->mediaControl), "QueryInterface(IMediaControl)")) {
         return false;
     }
+    // Best-effort: without it a lost device goes unnoticed, as it always did.
+    if (FAILED(impl_->graph.As(&impl_->mediaEvent))) {
+        impl_->mediaEvent.Reset();
+    }
 
     return true;
 }
@@ -546,6 +554,7 @@ void DirectShowWebcamCapture::stop() {
         impl_->mediaControl->Stop();
     }
     impl_->running = false;
+    impl_->mediaEvent.Reset();
     impl_->mediaControl.Reset();
     impl_->nullRenderer.Reset();
     impl_->sampleGrabber.Reset();
@@ -563,6 +572,11 @@ void DirectShowWebcamCapture::captureLoop() {
     const MmcssThread mmcss(L"Capture");
     const HRESULT coinitHr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
     while (!stopRequested_ && impl_ && impl_->sampleGrabber) {
+        // The sample grabber keeps handing back its last buffer after the
+        // camera is gone, so the frames cannot tell; the graph's events can.
+        if (deviceLeftGraph()) {
+            break;
+        }
         long bufferSize = 0;
         HRESULT hr = impl_->sampleGrabber->GetCurrentBuffer(&bufferSize, nullptr);
         if (SUCCEEDED(hr) && bufferSize > 0) {
@@ -579,6 +593,32 @@ void DirectShowWebcamCapture::captureLoop() {
     }
 }
 
+bool DirectShowWebcamCapture::deviceLeftGraph() {
+    if (!impl_->mediaEvent) {
+        return false;
+    }
+    long code = 0;
+    LONG_PTR param1 = 0;
+    LONG_PTR param2 = 0;
+    // A zero timeout drains what is queued without waiting for more.
+    while (SUCCEEDED(impl_->mediaEvent->GetEvent(&code, &param1, &param2, 0))) {
+        impl_->mediaEvent->FreeEventParams(code, param1, param2);
+        // EC_DEVICE_LOST's second parameter is 0 when the device was removed,
+        // 1 when it came back; a stream error or abort stops the graph.
+        const bool lost = (code == EC_DEVICE_LOST && param2 == 0) || code == EC_ERRORABORT ||
+            code == EC_STREAM_ERROR_STOPPED;
+        if (lost && !lost_.exchange(true)) {
+            reportWebcamLost(selectedDeviceName_, static_cast<HRESULT>(code));
+            return true;
+        }
+    }
+    return false;
+}
+
+bool DirectShowWebcamCapture::isLost() const {
+    return lost_;
+}
+
 void DirectShowWebcamCapture::storeFrame(const BYTE* buffer, long length) {
     const int destinationStride = width_ * 4;
     const int sourceStride = sourceStride_ > 0 ? sourceStride_ : destinationStride;
diff --git a/electron/native/wgc-capture/src/dshow_webcam_capture.h b/electron/native/wgc-capture/src/dshow_webcam_capture.h
index 2c4393288..5e26098d0 100644
--- a/electron/native/wgc-capture/src/dshow_webcam_capture.h
+++ b/electron/native/wgc-capture/src/dshow_webcam_capture.h
@@ -74,6 +74,11 @@ class DirectShowWebcamCapture {
      * none, the filter CLSID when no moniker names it), for the take's claims.
      */
     const std::wstring& deviceIdentity() const;
+    /**
+     * Did the graph report the device gone (EC_DEVICE_LOST removal, a stream
+     * error, or an abort)? Latched; safe to ask from any thread.
+     */
+    bool isLost() const;
     void storeFrame(const BYTE* buffer, long length);
 
 private:
@@ -85,6 +90,8 @@ class DirectShowWebcamCapture {
 
     struct Impl;
     void captureLoop();
+    /** Drains the graph's queued events; true once one of them says the device left. */
+    bool deviceLeftGraph();
     /**
      * Builds source -> sample grabber -> null renderer and connects it.
      *
@@ -121,6 +128,7 @@ class DirectShowWebcamCapture {
     Impl* impl_ = nullptr;
     std::thread thread_;
     std::atomic<bool> stopRequested_ = false;
+    std::atomic<bool> lost_ = false;
     std::mutex frameMutex_;
     std::vector<BYTE> latestFrame_;
     uint64_t latestFrameSequence_ = 0;
diff --git a/electron/native/wgc-capture/src/main.cpp b/electron/native/wgc-capture/src/main.cpp
index f6b4c8ffd..77dc692db 100644
--- a/electron/native/wgc-capture/src/main.cpp
+++ b/electron/native/wgc-capture/src/main.cpp
@@ -1179,6 +1179,21 @@ int wmain(int argc, wchar_t* argv[]) {
                 }
                 // Screen first, then every camera, as before there was more than one.
                 for (const auto& stream : webcams) {
+                    if (stream->active && stream->capture.isLost()) {
+                        // Unplugged mid-take: its file ends here instead of
+                        // repeating the last picture to the end, it is left out
+                        // of `webcamPaths` and still finalized at stop. The
+                        // screen and the other cameras go on.
+                        std::cerr << "ERROR: Camera " << stream->index
+                                  << " was lost during the take; disabling it" << std::endl;
+                        stream->active = false;
+                        if (inlineWebcam == stream.get()) {
+                            // Nor is its frozen picture drawn into the screen.
+                            inlineWebcam = nullptr;
+                            pictureChanged = true;
+                        }
+                        continue;
+                    }
                     if (stream->active && stream->pullVisibleFrame()) {
                         pictureChanged = pictureChanged || !stream->writeSeparate;
                     }
diff --git a/electron/native/wgc-capture/src/webcam_capture.cpp b/electron/native/wgc-capture/src/webcam_capture.cpp
index b67e1ceac..45d2ebdd7 100644
--- a/electron/native/wgc-capture/src/webcam_capture.cpp
+++ b/electron/native/wgc-capture/src/webcam_capture.cpp
@@ -2,6 +2,7 @@
 
 #include "realtime_scheduling.h"
 #include "webcam_format.h"
+#include "webcam_loss.h"
 
 #include <mfapi.h>
 #include <mferror.h>
@@ -10,6 +11,7 @@
 #include <algorithm>
 #include <chrono>
 #include <iostream>
+#include <optional>
 
 namespace {
 
@@ -403,6 +405,9 @@ void WebcamCapture::captureLoop() {
     CoInitializeEx(nullptr, COINIT_MULTITHREADED);
     const auto loopStartedAt = std::chrono::steady_clock::now();
 
+    // Start of the current run of failed reads; empty while reads succeed.
+    std::optional<std::chrono::steady_clock::time_point> failureRunStartedAt;
+
     while (!stopRequested_) {
         DWORD streamIndex = 0;
         DWORD flags = 0;
@@ -428,11 +433,27 @@ void WebcamCapture::captureLoop() {
             // wise write thousands of identical lines over a long take.
             readFailures_ += 1;
             lastReadFailure_ = hr;
+            const auto now = std::chrono::steady_clock::now();
+            if (!failureRunStartedAt) {
+                failureRunStartedAt = now;
+            }
+            const int64_t failingForMs =
+                std::chrono::duration_cast<std::chrono::milliseconds>(now - *failureRunStartedAt).count();
+            if (isWebcamLossResult(hr, false, failingForMs)) {
+                markLost(hr);
+                break;
+            }
             std::this_thread::sleep_for(std::chrono::milliseconds(20));
             continue;
         }
+        failureRunStartedAt.reset();
         if ((flags & MF_SOURCE_READERF_ENDOFSTREAM) != 0) {
             sawEndOfStream_ = true;
+            // Stop has its own way out of this loop; end of stream before it
+            // is the camera leaving.
+            if (!stopRequested_ && isWebcamLossResult(hr, true, 0)) {
+                markLost(hr);
+            }
             break;
         }
         if (!sample) {
@@ -513,6 +534,20 @@ void WebcamCapture::captureLoop() {
     CoUninitialize();
 }
 
+void WebcamCapture::markLost(HRESULT hr) {
+    if (lost_.exchange(true)) {
+        return;
+    }
+    reportWebcamLost(selectedDeviceName_, hr);
+}
+
+bool WebcamCapture::isLost() const {
+    if (usingDirectShow_) {
+        return directShowCapture_.isLost();
+    }
+    return lost_;
+}
+
 bool WebcamCapture::copyLatestFrame(WebcamFrameSnapshot& destination, uint64_t lastSeenSequence) {
     if (usingDirectShow_) {
         return directShowCapture_.copyLatestFrame(destination, lastSeenSequence);
diff --git a/electron/native/wgc-capture/src/webcam_capture.h b/electron/native/wgc-capture/src/webcam_capture.h
index 1d9e1fe5f..5888e5ed9 100644
--- a/electron/native/wgc-capture/src/webcam_capture.h
+++ b/electron/native/wgc-capture/src/webcam_capture.h
@@ -56,6 +56,13 @@ class WebcamCapture {
      */
     bool deliversNv12() const;
     const std::wstring& selectedDeviceName() const;
+    /**
+     * Has the camera left the take -- unplugged, or its driver given up?
+     *
+     * Latched: once true it stays true, and the camera delivers no more
+     * frames. Safe to ask from any thread.
+     */
+    bool isLost() const;
 
 private:
     bool selectDevice(
@@ -64,12 +71,15 @@ class WebcamCapture {
         const DeviceClaims& claims);
     bool configureReader(int requestedWidth, int requestedHeight, int requestedFps, bool preferNv12);
     void captureLoop();
+    /** Latches `lost_` and says so once; see `isWebcamLossResult`. */
+    void markLost(HRESULT hr);
 
     Microsoft::WRL::ComPtr<IMFMediaSource> mediaSource_;
     Microsoft::WRL::ComPtr<IMFSourceReader> sourceReader_;
     DirectShowWebcamCapture directShowCapture_;
     std::thread thread_;
     std::atomic<bool> stopRequested_ = false;
+    std::atomic<bool> lost_ = false;
     std::mutex frameMutex_;
     std::vector<BYTE> latestFrame_;
     uint64_t latestFrameSequence_ = 0;
diff --git a/electron/native/wgc-capture/src/webcam_loss.cpp b/electron/native/wgc-capture/src/webcam_loss.cpp
new file mode 100644
index 000000000..7548f84c2
--- /dev/null
+++ b/electron/native/wgc-capture/src/webcam_loss.cpp
@@ -0,0 +1,28 @@
+#include "webcam_loss.h"
+
+#include <mferror.h>
+
+#include <iostream>
+
+bool isWebcamLossResult(HRESULT hr, bool endOfStream, int64_t consecutiveFailureMs) {
+    if (SUCCEEDED(hr)) {
+        return endOfStream;
+    }
+    if (hr == MF_E_VIDEO_RECORDING_DEVICE_INVALIDATED || hr == MF_E_HW_MFT_FAILED_START_STREAMING) {
+        return true;
+    }
+    return consecutiveFailureMs >= kWebcamLossFailureRunMs;
+}
+
+void reportWebcamLost(const std::wstring& deviceName, HRESULT hr) {
+    std::string name;
+    const int size = WideCharToMultiByte(
+        CP_UTF8, 0, deviceName.data(), static_cast<int>(deviceName.size()), nullptr, 0, nullptr, nullptr);
+    if (size > 0) {
+        name.resize(static_cast<size_t>(size));
+        WideCharToMultiByte(
+            CP_UTF8, 0, deviceName.data(), static_cast<int>(deviceName.size()), name.data(), size, nullptr, nullptr);
+    }
+    std::cerr << "WARNING: Webcam lost during the take: " << name << " hr=0x" << std::hex
+              << static_cast<unsigned long>(hr) << std::dec << std::endl;
+}
diff --git a/electron/native/wgc-capture/src/webcam_loss.h b/electron/native/wgc-capture/src/webcam_loss.h
new file mode 100644
index 000000000..64af1f987
--- /dev/null
+++ b/electron/native/wgc-capture/src/webcam_loss.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <Windows.h>
+
+#include <cstdint>
+#include <string>
+
+/** How long reads may keep failing, back to back, before the camera counts as gone. */
+constexpr int64_t kWebcamLossFailureRunMs = 1000;
+
+/**
+ * Does this read result mean the camera has left the take?
+ *
+ * Media Foundation reports an unplugged camera as
+ * MF_E_VIDEO_RECORDING_DEVICE_INVALIDATED on every following ReadSample, and a
+ * camera whose driver gave up as MF_E_HW_MFT_FAILED_START_STREAMING; both are
+ * final. End of stream while the take is still running is the same thing said
+ * differently. Any other failure is forgiven once -- a camera can drop a read --
+ * but not for `kWebcamLossFailureRunMs` in a row: a reader that fails that long
+ * delivers nothing, and treating it as alive is what froze a file on its last
+ * picture for the rest of the take.
+ *
+ * `consecutiveFailureMs` is the time since the first failure of the current
+ * run; a successful read ends the run. Ignored when `hr` succeeded.
+ */
+bool isWebcamLossResult(HRESULT hr, bool endOfStream, int64_t consecutiveFailureMs);
+
+/**
+ * The one line both capture backends print when a camera leaves the take.
+ *
+ * `hr` is the read result that decided it, or the DirectShow event code when
+ * the graph reported the loss.
+ */
+void reportWebcamLost(const std::wstring& deviceName, HRESULT hr);
diff --git a/electron/native/wgc-capture/src/webcam_loss_test.cpp b/electron/native/wgc-capture/src/webcam_loss_test.cpp
new file mode 100644
index 000000000..2a8462f8d
--- /dev/null
+++ b/electron/native/wgc-capture/src/webcam_loss_test.cpp
@@ -0,0 +1,41 @@
+#include "webcam_loss.h"
+
+#include <mferror.h>
+
+#include <cstdio>
+
+namespace {
+int failures = 0;
+void expect(bool ok, const char* label) {
+    if (!ok) {
+        std::printf("FAIL %s\n", label);
+        ++failures;
+    }
+}
+}  // namespace
+
+int main() {
+    // The code the on-site test logged after the C920 was unplugged.
+    expect(isWebcamLossResult(MF_E_VIDEO_RECORDING_DEVICE_INVALIDATED, false, 0),
+           "device invalidated: lost on the first read");
+    expect(isWebcamLossResult(MF_E_HW_MFT_FAILED_START_STREAMING, false, 0),
+           "hardware failed to start streaming: lost");
+    expect(isWebcamLossResult(S_OK, true, 0), "end of stream during the take: lost");
+
+    expect(!isWebcamLossResult(E_FAIL, false, 0), "one other failure: not lost");
+    expect(!isWebcamLossResult(E_FAIL, false, kWebcamLossFailureRunMs - 1),
+           "other failures for just under a second: not lost");
+    expect(isWebcamLossResult(E_FAIL, false, kWebcamLossFailureRunMs),
+           "other failures for a second: lost");
+    expect(isWebcamLossResult(MF_E_NOTACCEPTING, false, 5000), "any failure code, long run: lost");
+
+    expect(!isWebcamLossResult(S_OK, false, 0), "S_OK: not lost");
+    expect(!isWebcamLossResult(S_OK, false, 5000), "S_OK ends a run of failures: not lost");
+
+    if (failures == 0) {
+        std::printf("webcam_loss_test: all assertions passed\n");
+        return 0;
+    }
+    std::printf("webcam_loss_test: %d failure(s)\n", failures);
+    return 1;
+}
diff --git a/scripts/build-windows-wgc-helper.mjs b/scripts/build-windows-wgc-helper.mjs
index 8f687dae9..927a7a392 100644
--- a/scripts/build-windows-wgc-helper.mjs
+++ b/scripts/build-windows-wgc-helper.mjs
@@ -132,6 +132,14 @@ if (!fs.existsSync(deviceSelectionTestPath)) {
 await run(deviceSelectionTestPath, [], { cwd: BUILD_DIR });
 console.log(`Passed ${deviceSelectionTestPath}`);
 
+const webcamLossTestPath = path.join(BUILD_DIR, "webcam_loss_test.exe");
+if (!fs.existsSync(webcamLossTestPath)) {
+	throw new Error(`WGC helper build completed but ${webcamLossTestPath} was not found.`);
+}
+// Guards that an unplugged camera ends its file instead of freezing on its last picture.
+await run(webcamLossTestPath, [], { cwd: BUILD_DIR });
+console.log(`Passed ${webcamLossTestPath}`);
+
 const frameVisibilityTestPath = path.join(BUILD_DIR, "frame_visibility_test.exe");
 if (!fs.existsSync(frameVisibilityTestPath)) {
 	throw new Error(`WGC helper build completed but ${frameVisibilityTestPath} was not found.`);

From 0aeb9145065a4bed9725dee0bc6499c70adc948c Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Mon, 5 Oct 2026 08:53:23 +0200
Subject: [PATCH 20/22] docs(e2e): log the on-site camera runs and the unplug
 fix

---
 technical-documentation/testing/manual-e2e-checklist.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.md
index 479a0910e..9e95eb6a8 100644
--- a/technical-documentation/testing/manual-e2e-checklist.md
+++ b/technical-documentation/testing/manual-e2e-checklist.md
@@ -871,3 +871,4 @@ On macOS 15.2+ it opens at launch, until it has been closed once, while one of i
 | 2026-10-03 | installed `v2.0.0-rc.15` (build run 37124242835, tag `ccd8b449`, NSIS sha512 matched `latest.yml`), installed over rc.12 for all users, About reports `2.0.0-rc.15` (`win32 x64 · nsis`, Electron 41.2.1, Chromium 146.0.7680.188, Node 24.14.1). `v2.0.0` was promoted from this candidate during the pass and differs from it only by the version bump (`eff86dcb`), so the results hold for the stable code | Windows 11 Home 26200, 1920×1080 @ 125 %, AMD Ryzen 5 7520U / Radeon iGPU, built-in USB2.0 HD UVC WebCam (best mode 1280×720@30), Microphone Array (AMD) | Partial — 6 defects | **Whole-file pass on Windows.** Real OS mouse and keyboard input throughout. Computer-use screenshots came back grey again, so the app was observed through `PrintWindow` on its own windows and DOM reads over CDP, and every picture and sound claim below was measured on the file with ffprobe/ffmpeg. **Defects:** (1) #1004, HUD drag at 125 %: the HUD window grows about 1.5 px per drag step (1180×882 → 1232×935 over ~43 steps) and the bar jumps by half the growth on release; after a long drag down the bar sat partly under the taskbar (centre y 1042, work area ends at 1032). (2) #1005, *Edit clip*: Reset, Cancel and Apply sit inside the scrolling body. In a 1240×1000 window (794 css px tall) the card is clipped above Apply, and a click where Apply should be lands on the backdrop, closing the dialog and discarding the edit. It fits when the window is maximized. (3) #1006, the rail's "Choose a clip to edit" menu renders under the timeline toolbar: Clip 2 and Clip 3 are covered (`elementFromPoint` returns `_tlToolbar`) and clicks on them do nothing. (4) #1007, a clip duplicated with Ctrl+C / Ctrl+V does not carry its anchored zoom or Full Camera region: `duplicateClip` in `src/lib/ai-edition/document/timeline.ts` copies only `trimRanges`. (5) #1008, zoom repel across a clip boundary: a zoom dragged into a neighbour that ends at its clip's end jumps past it into the next clip, shrinking from 12.97 to 8.23 s and leaving a zero-length fragment on the first clip. Ctrl+Z restores it. (6) #1009, the wordmark menu does not close on a click on the bare top bar. The header is a `-webkit-app-region: drag` area, which never delivers the document `mousedown` that `AppMenu` listens for. It does close on the preview, on a top-bar button and on the wordmark. **Passed: HUD and capture.** One HUD, `[content-protection] OFF` logged; horizontal ↔ vertical layout; every tooltip, idle and recording, beside or above the bar and unclipped; language menu (15 locales); camera and microphone toggles in one click; device settings: three inputs, level meter, live camera preview, camera quality row (1080p persisted across a relaunch; hand-edited 720p and an absent key both read 4K). Hide bar, then the tray overflow icon brings the HUD back; Quit leaves 0 processes; a second launch exits 0. With no source the record tooltip reads "Choose a screen or window to record" and one click opens the picker, then starts. While recording: source button disabled, toggles `aria-disabled`, gear inert, tray tooltip "Recording: Tout l'écran". Pause freezes the timer and resume advances it; restart starts a new helper and deletes the first file; cancel deletes the file and opens no editor. Stop opens the editor with "Recording added to a new project". Screen H.264 High bt709 1920×1080; AAC 48 kHz; webcam 1280×720 ~30 fps at 8 Mbit/s, the camera's best mode, not upscaled, matching `webcamFormat`. Microphone-only, system-audio-only and all-off takes behave; window source 1270×668, non-black; an odd 1001×601 window gives an even 992×596 file; a context menu inside the window is recorded and cut at its edge. Without the flag the HUD and an open Notes window are absent from the take. Record mode: rows, live camera preview, microphone meter, device switch, source modal with badge, *Start recording* hands over to the HUD; auto-zoom on gives one merged zoom over three clicks, off gives none, and the setting persists; editable cursor off hides the auto-zoom row and the Cursor facet; *Hide desktop icons* shows a bare wallpaper and restores the icons after. **Passed: editor.** Rename, Saved dot, tabs, chat panel toggle, tooltips with key chips, dividers; play, pause, seek playing and paused, ±1 frame arrows, stop at end; ruler click and drag, navigator narrow and pan, labels without collision, playhead within 0.5 px; Ctrl+S toast with a stable top bar. Clips: media card drag and *Add to timeline*, reorder, Edit clip grips, 1:1 crop held through a corner drag, Free, Cancel, pencil, delete. Trim, zoom (levels, custom, out-of-range message, focus drag, 3D modes), speed (presets, custom, 16× cap message, playback at 16×), annotation (text, sizes, plates, palette, Typewriter, image, arrow, blur mosaic and smooth, oval, clamped, dragged into padding); Ctrl+D, Ctrl+Z, Ctrl+Shift+Z. Modifiers inside a trim fire on the parked frame. Copy and paste of zoom, annotation and trim with their toasts and properties; an empty copy is a no-op; deleting a clip removes its modifiers; Edit clip clamps them; a Full Camera region across a junction splits and merges as clips move. Imported music: fragments across a junction with `offsetMs`, −18 dB and 1 s fades, gain, *Reset audio*; voiceover lands at the playhead. Transcript: clip order, silences, monotonic word seeks, live cue, Backspace skip and restore, silence trim; captions in four styles and six anchors; French translation with a *Display* row, and deleting it leaves the words untouched; typing in the packaged gate does nothing; a double-click correction survives *Regenerate as English* (model reused); 101 languages, detected language on the card. Composition: colour, gradient and one-colour gradient, wallpaper, animations move during playback only (21–23 distinct frames in 3 s, None 1), blur, 9:16 with Whole and Follow cursor, Auto padding with even borders, shadows, four frame styles in both themes. Camera layout: four presets, mirror, square, size (default 40, max 60), roundness, positions; background Cutout, Blur with an intensity slider, Custom image and colour, and the custom-colour mask reaches a 720p export; webcam crop corner zoom (124 %) and frame move. Audio facet: +6.5 dB raises the export from −17.2 to −12.7 LUFS with the peak held at −1.3 dBFS; reset returns 0 dB. Cursor facet: hide, style, size (to 5.8 of 6) and 3D cursor all show in the preview. Depth of field appears once a zoom has a 3D preset and changes the preview. Wordmark menu: rows as listed, About row version, arrows wrap both ways; Keyboard Shortcuts as one dialog: Z → Q changes the lane hint, Q adds a zoom, Z does nothing, reset restores Z; Ctrl+O; AI settings as one dialog; light and dark themes, dialogs included; French UI with one-line menu rows (#969), back to English; About lists the versions and channel, and Copy puts the same block on the clipboard; the HUD panel's version row and Check for Updates ("Checking…", disabled, the same dialog as the menu, re-enabled after). AI chat (deepseek): "add one zoom at 2x from 5 s to 8 s" lands as 5–8 s at 2.20× with the reason given, is undone by one Ctrl+Z and redone. Closing the editor quits the app and writes `editor-window.json` (`maximized: false`); after a relaunch the last project's settings and the main project's two clips, crop, regions, music, voiceover and captions are as left, and a paste before any copy changes nothing. A schema-4 project from July opens, migrates to schema 8, and keeps its clip, seven zooms and annotation. **Export:** MP4 1080p30 of the two-clip project, 10288 frames, audio and video within one frame, −16.0 LUFS and −1.4 dBTP, annotation upright, caption plate at x = 108 for a 10 % inset, Full Camera where mapped, music ducked about 10 dB under speech with fades at the track's own edges, muted track absent, voiceover not stretched by a 2× region. GIF 25 fps: cancel removes the partial file and leaves the existing destination untouched; the full render (~127 s, #952) gives 434 frames, infinite loop, consistent in ffmpeg and GDI+. **Also seen:** a take with a ~4 s pause had audio 1.09 s past its video, against 0.02–0.17 s without a pause; three dedicated paused takes gave 0.40, 0.15 and 0.03 s. The export ends each clip at its last video frame (10288 frames against the 10320 the progress counted), so the timeline and the export disagree by that tail. The editor reopens 4 px taller than it closed at 125 %. **Not run:** the A/V offset across a pause measured directly (the flash-and-beep rig never painted on the captured desktop), the HUD with no camera (needs the camera disabled in Windows), tray right-click menus (Update Settings, Stop Recording, Save Diagnostics: Explorer is granted click-only), the Alt Help menu (an Alt tap showed nothing, inconclusive), Ctrl/Shift+wheel on the timeline, cursor auto-hide, smoothing, motion blur and click effects, annotation animations other than Typewriter, Depth of field in an export, chat rewind, history and Smart cuts, a software-encoder take, the crackle and hole scan, multiple displays, 4K and 1440p cameras, 150 % DPI, macOS and Linux. |
 | 2026-10-04 | dev `feat/multi-camera-recording` at `212c07f7` (feature head `23ea0751` + the HUD probe lint fix); `wgc-capture.exe` rebuilt from this tree by `npm run build:native:win` | Windows 11 on ARM64 (Snapdragon X Elite), one built-in camera (`AI Front Camera`), driven without computer-use | **Partial — the two-webcam run on site is outstanding; sub-project not complete until logged** | **Ran:** unit suite (`npm run test`, 304 of 305 files, the one failure `LeftPanel.copyMessage.test.tsx` passed alone, a load flake), both `tsc`, lint (0 errors, 26 warnings, the base count), `i18n:check`; the helper's native unit tests (`node scripts/build-windows-wgc-helper.mjs`, all pass); helper smoke runs `npm run test:wgc-helper:win`, `-- --webcam` and `-- --webcam --missing-second-webcam` (index 1 dropped and named, camera 1 kept); a direct helper run listing the one camera twice: camera 1 recorded, camera 2 dropped with `webcam-unavailable` index 1 and "already recording in this take", `webcamPaths` held one file, exit 0, camera file 4.81 s against the screen's 4.80 s. **Not run:** the app click-through (HUD *Additional cameras*, editor, save and reopen, the session manifest's `additionalWebcams`, the "Not recorded" notice): no computer-use here and only one camera. **Not covered at all:** two real cameras recording together, identical-name Brios, 1080p and 4K load, clap sync, macOS and Linux. |
 | 2026-10-05 | dev `feat/multi-camera-recording` at `86d49475`; `wgc-capture.exe` from `electron/native/wgc-capture/build` (4 Oct 13:05, `findstr` hit the fix-wave string *Could not remove the dropped camera file* and the control `encoder-selection`); `compositor_view.node` built from this tree by `npm run build:native:compositor` (ARM64) and loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE` next to the vendored win32-arm64 ffmpeg | Windows 11 on ARM64 (Snapdragon X Elite), **Logitech BRIO** (USB) + built-in `AI Front Camera`, 2560×1440 display | **Partial — two real cameras pass; Brio + C920, two identical Brios, 4K load and a mid-take camera loss not run yet** | *Helper:* Brio as camera 1 + built-in as camera 2 at 1080p30, 38 s take with three claps — both camera files 1146 frames / 38.19 s, screen 38.20 s at a steady 30 fps (`[pacing] frames=1146 elapsed_ms=38201`), camera 2 skipped the claimed Brio (`already recording in this take`), `webcamPaths` listed both. Clap sync by per-frame motion cross-correlation: 0 frames over the whole take, ≤ 1 frame (33 ms) per 3 s window; an 8-frame strip of the strongest clap shows the hands meeting and opening in the same frames on both. *App (HUD driven by the user):* Brio as camera 1, built-in ticked under *Additional cameras* — three files written, session `additionalWebcams` with label `AI Front Camera`, no *Not recorded* notice; Studio shows screen + camera 1 as before; the project holds `additionalCameraTracks` (1920×1080, offset 0, label) and keeps it after reopen, an edit and save. | The editor cannot select camera 2 yet — by design, sub-projects 2/3. First dev launch had no `compositor_view.node` in the worktree (blank Studio: `native addon not present`) — environment, not product. |
+| 2026-10-05 | dev `feat/multi-camera-recording` at `e0067391` (`fix(wgc): stop and report a camera that is unplugged mid-take`); `wgc-capture.exe` rebuilt by `npm run build:native:win`, `findstr` hit *Webcam lost during the take* and the control `encoder-selection` in `build` and `binwin32-x64` | Windows 11 on ARM64 (Snapdragon X Elite), **two Logitech BRIO** (identical names, USB instances `C&1EF69AFB` and `9&299A5C35`), **HD Pro Webcam C920**, built-in `AI Front Camera`; helper-level runs with a `webcams` list | **Partial — every on-site case passes at 1080p; 4K with a second camera paces cameras at 27.8 fps; the unplug notice was checked at helper level, not in the app UI** | *Brio + C920, 1080p:* 310/310/310 frames (camera 1, camera 2, screen). *Two identical Brios:* camera 2 skipped the claimed Brio (`already recording in this take`) and opened the other one — two different pictures; which Brio became camera 1 followed enumeration order, not intent (known limitation). *All four cameras at once, 1080p:* four different pictures, 392 frames each, screen 392 at a steady 30 fps. *4K:* one Brio alone 3840×2160 at 30 fps (401/401); two Brios requested at 4K → the Brio on a cheap USB cable only offers 1080p even alone (USB 2 link — hardware), and with 4K + 1080p both cameras paced at **27.8 fps** (363 frames in 13.07 s), screen 29.5 fps — all cameras are converted and encoded on the screen writer thread; follow-up: a worker thread per camera. *Unplug the C920 mid-take:* before the fix the C920 file ran on with a frozen picture and was still listed (`readFailures=737 lastReadHr=0xc00d3ea2`); after `e0067391` the helper logs `Webcam lost during the take: HD Pro Webcam C920 hr=0xc00d3ea2`, the C920 file ends at the loss (200 frames / 6.66 s), the Brio and screen run the full 27.7 s, and `webcamPaths` lists only the Brio — the input Electron turns into *Stopped early: …*. | The *Stopped early* toast itself was not watched in the app; it is unit-tested (`labelsOfWebcamsStoppedEarly`, renderer stop test). |

From 08576219773b703e118f9b03f3a8f25e1f4b2ab1 Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Sat, 3 Oct 2026 10:07:18 +0200
Subject: [PATCH 21/22] feat(camera): desk view for Full Camera sections, with
 a covered tilt
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A Full Camera section can now show a webcam tilted down onto the desk: "Desk view"
in the inspector turns the camera 180°, switches the mirror off for that section
(otherwise text on the page reads back to front) and shows the whole camera frame
instead of the face crop. The timeline marks such sections with a rotate icon.

The moment the camera is tilted is covered at both ends of the section: the whole
camera picture is blurred and dimmed for the Full Camera grow (and the shrink),
fading in and out around it, with a translated "Desk mode" label over it that can be
switched off per section. Preview and export render it identically through the
compositor's frame plan.

- Rust: per-frame orientation (u/v bound swaps, crop bypass) and cover strength,
  a `LayerCB.cover` lane (HLSL, WGSL, MSL), the blur clamped to the camera's valid
  area so aligned decoder padding never bleeds in; the label is drawn at the
  cover strength of the same frame, so it fades exactly with the cover.
- App: `rotation` / `mirror` / `deskLabel` on Full Camera regions (defaults are not
  stored), store and persistence, inspector controls, one generated label annotation
  per projected piece, translations in every locale.
- Tests for each layer; WGSL is validated with naga on every host.
---
 crates/compositor/src/compositor_linux.rs     |  39 ++-
 crates/compositor/src/compositor_macos.rs     |  25 +-
 crates/compositor/src/compositor_windows.rs   |  30 ++-
 crates/compositor/src/frame_geometry.rs       | 249 +++++++++++++++++-
 crates/compositor/src/regions.rs              | 213 ++++++++++++++-
 crates/compositor/src/scene.rs                |  12 +-
 crates/compositor/src/shaders.hlsl            |  27 +-
 crates/compositor/src/shaders.metal           |  38 ++-
 crates/compositor/src/text_anim.rs            |  60 ++++-
 crates/compositor/src/vk_shaders/layer.wgsl   |  24 +-
 .../NativeCompositorOverlay.test.tsx          |  45 +++-
 .../ai-edition/NativeCompositorOverlay.tsx    |  11 +-
 .../ai-edition/v4/EditorShellV4.module.css    |   7 +
 .../ai-edition/v4/FloatingInspector.test.tsx  |  83 ++++++
 .../ai-edition/v4/FloatingInspector.tsx       |  64 +++++
 src/components/ai-edition/v4/V4Timeline.tsx   |  15 +-
 .../video-editor/projectPersistence.test.ts   |  30 +++
 .../video-editor/projectPersistence.ts        |   6 +
 src/components/video-editor/types.ts          |   9 +-
 src/i18n/locales/ar/settings.json             |  12 +
 src/i18n/locales/cs/settings.json             |  12 +
 src/i18n/locales/de/settings.json             |  12 +
 src/i18n/locales/en/settings.json             |  12 +
 src/i18n/locales/es/settings.json             |  12 +
 src/i18n/locales/fr/settings.json             |  12 +
 src/i18n/locales/it/settings.json             |  12 +
 src/i18n/locales/ja-JP/settings.json          |  12 +
 src/i18n/locales/ko-KR/settings.json          |  12 +
 src/i18n/locales/pt-BR/settings.json          |  12 +
 src/i18n/locales/ru/settings.json             |  12 +
 src/i18n/locales/tr/settings.json             |  12 +
 src/i18n/locales/vi/settings.json             |  12 +
 src/i18n/locales/zh-CN/settings.json          |  12 +
 src/i18n/locales/zh-TW/settings.json          |  12 +
 .../store/documentWriteAudit.test.ts          |  12 +
 src/lib/ai-edition/store/useTimeline.test.ts  | 107 ++++++++
 src/lib/ai-edition/store/useTimeline.ts       |  65 ++++-
 .../ai-edition/timeline/timelineMap.test.ts   |  12 +
 src/lib/cameraOrientation.test.ts             |  82 ++++++
 src/lib/cameraOrientation.ts                  |  52 ++++
 src/lib/deskCover.ts                          |   9 +
 src/native/sceneDescription.test.ts           | 159 ++++++++++-
 src/native/sceneDescription.ts                | 120 ++++++++-
 .../testing/manual-e2e-checklist.md           |   7 +
 44 files changed, 1715 insertions(+), 77 deletions(-)
 create mode 100644 src/lib/cameraOrientation.test.ts
 create mode 100644 src/lib/cameraOrientation.ts
 create mode 100644 src/lib/deskCover.ts

diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs
index f7c5204b6..c2b8bc17b 100644
--- a/crates/compositor/src/compositor_linux.rs
+++ b/crates/compositor/src/compositor_linux.rs
@@ -67,12 +67,12 @@ fn layer_source(models: bool) -> String {
 /// en parcourant les 18 wallpapers livres) en laissant le jeu actif resident.
 const IMG_CACHE_BUDGET_BYTES: u64 = 512 * 1024 * 1024;
 
-/// Taille du buffer uniforme d'un calque : `LayerCB` entier (176 octets), le `struct Layer` de
+/// Taille du buffer uniforme d'un calque : `LayerCB` entier (192 octets), le `struct Layer` de
 /// `layer.wgsl`. `blur.wgsl` n'en lit que les 128 premiers.
 const LAYER_BYTES: u64 = std::mem::size_of::<LayerCB>() as u64;
 
 /// `&LayerCB` -> ses octets. `LayerCB` est `#[repr(C, align(16))]`, son layout EST le buffer
-/// uniforme WGSL (dix vec4 et un vec2 + 2 f32 = 176 octets).
+/// uniforme WGSL (douze vec4 = 192 octets).
 fn layer_bytes(cb: &LayerCB) -> &[u8] {
     unsafe { std::slice::from_raw_parts(cb as *const LayerCB as *const u8, LAYER_BYTES as usize) }
 }
@@ -2485,17 +2485,16 @@ impl Compositor {
             let [cu0, cv0, cu1, cv1] = crate::frame_geometry::webcam_source_rect(
                 [wcw, wch],
                 [wtw as f32, wth as f32],
-                scene_ref
-                    .as_ref()
-                    .and_then(|scene| scene.layout.webcam_crop),
+                if g.webcam.full_frame {
+                    None
+                } else {
+                    scene_ref.as_ref().and_then(|scene| scene.layout.webcam_crop)
+                },
                 g.w_px[0] / g.w_px[1].max(0.0001),
             );
-            // MIROIR : on inverse l'intervalle u. Le VS interpole `src`
-            // lineairement et `fs_main` ne re-clampe pas `i.uv`, donc un
-            // intervalle a l'envers suffit -- aucune retouche du WGSL. Apres le
-            // cover-crop les deux bornes sont strictement a l'interieur de la
-            // texture, donc le sampler ClampToEdge ne bave pas sur les bords.
-            let (u0, u1) = if lp.webcam_mirror { (cu1, cu0) } else { (cu0, cu1) };
+            // Mirror and the desk-shot turn are both bound swaps: u for horizontal, v for vertical.
+            let (u0, u1) = if g.webcam.flip_u { (cu1, cu0) } else { (cu0, cu1) };
+            let (v0, v1) = if g.webcam.flip_v { (cv1, cv0) } else { (cv0, cv1) };
             // `src_prev` doit valoir EXACTEMENT le `src` de ce draw, miroir
             // compris : le shader s'en sert pour reconstruire l'UV de la frame
             // precedente, et un rect source qui ne correspond pas au calque
@@ -2503,7 +2502,7 @@ impl Compositor {
             // n'a jamais ete affichee. Seul `dst_prev` porte le mouvement.
             let cb = LayerCB {
                 dst: g.w_dst,
-                src: [u0, cv0, u1, cv1],
+                src: [u0, v0, u1, v1],
                 quad_px: g.w_px,
                 radius_px: g.w_radius,
                 mode: 0.0,
@@ -2515,9 +2514,10 @@ impl Compositor {
                 // `fx.z` = mode, `fx.w` = intensite du flou. Contrat commun aux
                 // trois back-ends, cf. `layer.wgsl` et `webcam-segmentation.md`.
                 fx: [w_valid[0], w_valid[1], effect_code, blur_intensity],
-                src_prev: [u0, cv0, u1, cv1],
+                src_prev: [u0, v0, u1, v1],
                 dst_prev: g.w_dst_prev,
                 mb: [g.mb_taps, g.mb_amount, 1.0, 0.0],
+                cover: [g.webcam_cover, 0.04 * g.w_px[0].min(g.w_px[1]) * g.webcam_cover, 0.35, 0.0],
                 ..Default::default()
             };
             // Le masque est lie par `make_bind` sur tous les draws, pas seulement
@@ -2753,6 +2753,13 @@ impl Compositor {
                         if text.content.trim().is_empty() {
                             continue;
                         }
+                        // The desk label shows only while the camera is covered: skip the rest of
+                        // its section before rasterizing anything.
+                        if crate::text_anim::is_desk_cover(text.animation.as_deref())
+                            && g.webcam_cover <= 0.0
+                        {
+                            continue;
+                        }
                         let color = parse_hex(&text.color).unwrap_or([1.0, 1.0, 1.0, 1.0]);
                         let background =
                             parse_hex(&text.background_color).unwrap_or([0.0, 0.0, 0.0, 0.0]);
@@ -2787,10 +2794,11 @@ impl Compositor {
                         // et remis a l'echelle de la sortie, comme la taille de
                         // police : en px absolus la meme animation sauterait deux
                         // fois plus haut dans un rendu 4K que dans l'apercu.
-                        let anim = crate::text_anim::text_animation_state(
+                        let anim = crate::text_anim::annotation_text_state(
                             text.animation.as_deref(),
                             (g.source_t - a.start_sec as f32) * 1000.0,
                             ((a.end_sec - a.start_sec) * 1000.0) as f32,
+                            g.webcam_cover,
                         );
                         let anim_px = rh / crate::text_anim::ANIMATION_REFERENCE_HEIGHT;
                         let (mut ax, mut ay, mut aw, mut ah) = (
@@ -4888,6 +4896,9 @@ mod tests {
             clip_index: None,
             start_sec: 2.0,
             end_sec: 8.0,
+            rotation: 0,
+            mirror: None,
+            full_frame: false,
         });
         // 5 s : la montee (~1 s) est finie, le retour (~1,5 s) n'a pas commence.
         comp.set_timeline_time(Some(5.0));
diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rs
index 5440cfb51..493504be3 100644
--- a/crates/compositor/src/compositor_macos.rs
+++ b/crates/compositor/src/compositor_macos.rs
@@ -1673,6 +1673,13 @@ impl Compositor {
                     if text.content.trim().is_empty() {
                         continue;
                     }
+                    // The desk label shows only while the camera is covered: skip the rest of
+                    // its section before rasterizing anything.
+                    if crate::text_anim::is_desk_cover(text.animation.as_deref())
+                        && g.webcam_cover <= 0.0
+                    {
+                        continue;
+                    }
                     let spec = crate::text::TextSpec {
                         content: text.content.clone(),
                         color: parse_hex(&text.color).unwrap_or([1.0, 1.0, 1.0, 1.0]),
@@ -1706,10 +1713,11 @@ impl Compositor {
                     }) else {
                         continue;
                     };
-                    let anim = crate::text_anim::text_animation_state(
+                    let anim = crate::text_anim::annotation_text_state(
                         text.animation.as_deref(),
                         (t - a.start_sec as f32) * 1000.0,
                         ((a.end_sec - a.start_sec) * 1000.0) as f32,
+                        g.webcam_cover,
                     );
                     let anim_px = rh / crate::text_anim::ANIMATION_REFERENCE_HEIGHT;
                     let (mut ax, mut ay, mut aw, mut ah) = (
@@ -2663,10 +2671,16 @@ impl Compositor {
             let [cu0, cv0, cu1, cv1] = crate::frame_geometry::webcam_source_rect(
                 [wcw, wch],
                 [wtw as f32, wth as f32],
-                scene_ref.as_ref().and_then(|scene| scene.layout.webcam_crop),
+                if g.webcam.full_frame {
+                    None
+                } else {
+                    scene_ref.as_ref().and_then(|scene| scene.layout.webcam_crop)
+                },
                 g.w_px[0] / g.w_px[1].max(0.0001),
             );
-            let (u0, u1) = if lp.webcam_mirror { (cu1, cu0) } else { (cu0, cu1) };
+            // Mirror and the desk-shot turn are both bound swaps: u for horizontal, v for vertical.
+            let (u0, u1) = if g.webcam.flip_u { (cu1, cu0) } else { (cu0, cu1) };
+            let (v0, v1) = if g.webcam.flip_v { (cv1, cv0) } else { (cv0, cv1) };
             let webcam_is_block = matches!(
                 g.scene_preset.as_deref(),
                 Some("dual-frame") | Some("vertical-stack")
@@ -2733,7 +2747,7 @@ impl Compositor {
                 enc,
                 &LayerCB {
                     dst: g.w_dst,
-                    src: [u0, cv0, u1, cv1],
+                    src: [u0, v0, u1, v1],
                     quad_px: g.w_px,
                     radius_px: g.w_radius,
                     mode: 0.0,
@@ -2741,9 +2755,10 @@ impl Compositor {
                     // plus lu, le fond ayant déjà été peint sous la caméra.
                     color: [0.0, 0.0, 0.0, 1.0],
                     fx: [w_valid[0], w_valid[1], effect_code, blur_intensity],
-                    src_prev: [u0, cv0, u1, cv1],
+                    src_prev: [u0, v0, u1, v1],
                     dst_prev: g.w_dst_prev,
                     mb: [g.mb_taps, g.mb_amount, 1.0, 0.0],
+                    cover: [g.webcam_cover, 0.04 * g.w_px[0].min(g.w_px[1]) * g.webcam_cover, 0.35, 0.0],
                     ..Default::default()
                 },
                 wy,
diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rs
index 11952713d..ebf106f79 100644
--- a/crates/compositor/src/compositor_windows.rs
+++ b/crates/compositor/src/compositor_windows.rs
@@ -2438,13 +2438,16 @@ impl Compositor {
         let [su0, sv0, su1, sv1] = crate::frame_geometry::webcam_source_rect(
             [wcw, wch],
             [wtw as f32, wth as f32],
-            scene_ref
-                .as_ref()
-                .and_then(|scene| scene.layout.webcam_crop),
+            if g.webcam.full_frame {
+                None
+            } else {
+                scene_ref.as_ref().and_then(|scene| scene.layout.webcam_crop)
+            },
             w_px[0] / w_px[1].max(0.0001),
         );
-        // miroir = échanger les bornes u du rect source (flip horizontal).
-        let (u0, u1) = if lp.webcam_mirror { (su1, su0) } else { (su0, su1) };
+        // Mirror and the desk-shot turn are both bound swaps: u for horizontal, v for vertical.
+        let (u0, u1) = if g.webcam.flip_u { (su1, su0) } else { (su0, su1) };
+        let (v0, v1) = if g.webcam.flip_v { (sv1, sv0) } else { (sv0, sv1) };
         if lp.has_webcam {
             // L'ombre portée appartient à la bulle flottante PiP : elle se retire avec elle
             // (`shape_fade`), pour qu'au plein écran plus rien n'encadre la caméra. C'est une
@@ -2508,7 +2511,7 @@ impl Compositor {
             self.draw_video(
                 &LayerCB {
                     dst: w_dst,
-                    src: [u0, sv0, u1, sv1],
+                    src: [u0, v0, u1, v1],
                     quad_px: w_px,
                     radius_px: w_radius,
                     mode: 0.0,
@@ -2516,9 +2519,10 @@ impl Compositor {
                     // plus lu, le fond ayant déjà été peint sous la caméra.
                     color: [0.0, 0.0, 0.0, 1.0],
                     fx: [w_valid[0], w_valid[1], effect_code, blur_intensity],
-                    src_prev: [u0, sv0, u1, sv1], // src fixe (pas de zoom webcam)
+                    src_prev: [u0, v0, u1, v1], // src fixe (pas de zoom webcam)
                     dst_prev: w_dst_prev,
                     mb: [mb_taps, mb_amount, 1.0, 0.0],
+                    cover: [g.webcam_cover, 0.04 * w_px[0].min(w_px[1]) * g.webcam_cover, 0.35, 0.0],
                     ..Default::default()
                 },
                 &wy,
@@ -2741,6 +2745,13 @@ impl Compositor {
                     if text.content.trim().is_empty() {
                         continue;
                     }
+                    // The desk label shows only while the camera is covered: skip the rest of
+                    // its section before rasterizing anything.
+                    if crate::text_anim::is_desk_cover(text.animation.as_deref())
+                        && g.webcam_cover <= 0.0
+                    {
+                        continue;
+                    }
                     // `font_size_rel` est une fraction de la HAUTEUR DE LA BOÎTE D'ANCRAGE — rect
                     // écran, ou cadre de sortie pour un sous-titre (cf. le contrat et
                     // `annotationScale.ts`) : on la ramène en pixels de sortie ici, avec le même
@@ -2786,10 +2797,13 @@ impl Compositor {
                     // dispose ici) : dans une région accélérée, elle défile donc au rythme du
                     // clip. À vitesse 1 — le cas de toutes les annotations existantes — c'est
                     // exactement le timing de l'aperçu DOM.
-                    let anim = crate::text_anim::text_animation_state(
+                    // The desk label is the exception: its opacity is the camera cover, which
+                    // runs on the screen clock (`annotation_text_state`).
+                    let anim = crate::text_anim::annotation_text_state(
                         text.animation.as_deref(),
                         (t - annotation.start_sec as f32) * 1000.0,
                         ((annotation.end_sec - annotation.start_sec) * 1000.0) as f32,
+                        g.webcam_cover,
                     );
                     // Les décalages sont donnés à la hauteur de référence : on les ramène à la
                     // sortie, comme la taille de police, pour que l'animation ait la même
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index a8ef080e4..a719b9673 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -27,7 +27,7 @@
 use crate::config::Cfg;
 use crate::scene::{Scene, SceneCrop};
 
-/// Constant buffer d'un calque : **176 octets**, un par draw.
+/// Constant buffer d'un calque : **192 octets**, un par draw.
 ///
 /// C'est le contrat partagé par les trois côtés — `cbuffer Layer` dans `shaders.hlsl`,
 /// `struct Layer` dans `shaders.metal` et `vk_shaders/layer.wgsl`, et ce struct. Ils doivent
@@ -35,13 +35,13 @@ use crate::scene::{Scene, SceneCrop};
 /// produit un shader qui lit `color` là où on a écrit `fx`.
 ///
 /// `align(16)` vient de la version macOS ; sous `repr(C)` seul, les offsets sont déjà
-/// 0/16/32/40/44/48/64/80/96/112/128/144/160 des deux côtés — l'alignement Rust ne change que
+/// 0/16/32/40/44/48/64/80/96/112/128/144/160/176 des deux côtés — l'alignement Rust ne change que
 /// l'adresse du struct, pas son contenu, et Windows le `copy_nonoverlapping` dans un
 /// constant buffer mappé où l'alignement source est sans effet. Les deux formes étaient
 /// donc compatibles ; les unifier évite qu'elles cessent de l'être.
 ///
 /// (Le commentaire d'origine annonçait « 64 octets ». Il n'a jamais été juste : dix champs,
-/// trente-deux `f32`. Les trois derniers, le flou de mouvement de l'écran incliné, en font 176.)
+/// trente-deux `f32`. Les trois suivants, le flou de mouvement de l'écran incliné, en font 176, et `cover`, le voile de la vue bureau, 192.)
 #[repr(C, align(16))]
 #[derive(Clone, Copy, Default)]
 pub struct LayerCB {
@@ -62,6 +62,9 @@ pub struct LayerCB {
     pub trail_a: [f32; 4],
     pub trail_b: [f32; 4],
     pub trail_mb: [f32; 4],
+    /// Desk-view cover of the webcam layer: x = strength 0..1, y = blur radius (quad px),
+    /// z = dim factor, w unused. Zero everywhere else.
+    pub cover: [f32; 4],
 }
 
 impl LayerCB {
@@ -330,6 +333,33 @@ pub(crate) fn cover_crop_uv(visible: [f32; 2], tex: [f32; 2], box_ar: f32) -> (f
     (u0, v0, u1, v1)
 }
 
+/// How the webcam texture is laid onto its quad this frame. The backends swap the source
+/// rect's u bounds for `flip_u` and its v bounds for `flip_v` — 180° is both — and drop the
+/// webcam crop for `full_frame`. Derived per frame because a Full Camera region can turn
+/// the camera for a desk shot.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct WebcamOrientation {
+    pub flip_u: bool,
+    pub flip_v: bool,
+    pub full_frame: bool,
+}
+
+pub fn webcam_orientation(
+    region: Option<&crate::scene::SceneCameraFullscreenRegion>,
+    layout_mirror: bool,
+) -> WebcamOrientation {
+    let Some(r) = region else {
+        return WebcamOrientation { flip_u: layout_mirror, flip_v: false, full_frame: false };
+    };
+    let turned = r.rotation == 180;
+    let mirror = r.mirror.unwrap_or(layout_mirror);
+    WebcamOrientation {
+        flip_u: mirror ^ turned,
+        flip_v: turned,
+        full_frame: turned && r.full_frame,
+    }
+}
+
 /// Camera equivalent of the screen crop pipeline: apply the user crop first, then a centred
 /// cover-crop inside that authored window so arbitrary layout slots never stretch the image.
 pub(crate) fn webcam_source_rect(
@@ -1908,6 +1938,10 @@ pub struct FrameGeometry {
     pub w_px: [f32; 2],
     pub w_radius: f32,
     pub shape_fade: f32,
+    /// Orientation of the webcam this frame (mirror, desk-shot turn, crop bypass).
+    pub webcam: WebcamOrientation,
+    /// Desk-view cover strength of the webcam this frame, 0..1 (`camera_fullscreen_cover_at`).
+    pub webcam_cover: f32,
     /// Cadre autour de l'écran : chrome de fenêtre plat (mode 14) ou appareil modelé (mode 17).
     /// `None` : aucun, et le rendu est celui d'avant le cadre, à l'octet. `Some` : `s_dst` est
     /// déjà la boîte rétrécie, et `s_radius` le rayon des coins de l'écran — des seuls coins BAS
@@ -3061,6 +3095,11 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
             crate::regions::camera_fullscreen_progress_at(cam_regions, source_t_prev, &clock);
         let shape_fade =
             crate::regions::camera_fullscreen_shape_at(cam_regions, source_t, &clock);
+        let webcam = webcam_orientation(
+            crate::regions::camera_fullscreen_region_at(cam_regions, source_t, &clock),
+            lp.webcam_mirror,
+        );
+        let webcam_cover = crate::regions::camera_fullscreen_cover_at(cam_regions, source_t, &clock);
         // rétrécissement réactif : la webcam garde 70 % de sa taille pendant un zoom actif, quel
         // que soit son niveau (elle suivait 1/zoom, et rétrécissait donc d'autant plus que le zoom
         // était profond : ×0,6 au zoom maximal). L'enveloppe est celle de la région : elle descend
@@ -3504,6 +3543,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
         w_px,
         w_radius,
         shape_fade,
+        webcam,
+        webcam_cover,
         window_frame,
         screen_mask,
     }
@@ -6305,6 +6346,7 @@ mod tests {
                 .into_iter()
                 .chain(c.quad_px)
                 .chain([c.radius_px, c.mode])
+                .chain(c.cover)
                 .map(f32::to_bits)
                 .collect()
         })
@@ -7302,7 +7344,7 @@ mod tests {
     #[test]
     fn layer_cb_matches_the_shader_constant_buffer() {
         use std::mem::{align_of, offset_of, size_of};
-        assert_eq!(size_of::<LayerCB>(), 176);
+        assert_eq!(size_of::<LayerCB>(), 192);
         assert_eq!(align_of::<LayerCB>(), 16);
         for (name, got, want) in [
             ("dst", offset_of!(LayerCB, dst), 0),
@@ -7318,11 +7360,102 @@ mod tests {
             ("trail_a", offset_of!(LayerCB, trail_a), 128),
             ("trail_b", offset_of!(LayerCB, trail_b), 144),
             ("trail_mb", offset_of!(LayerCB, trail_mb), 160),
+            ("cover", offset_of!(LayerCB, cover), 176),
         ] {
             assert_eq!(got, want, "offset de `{name}`");
         }
     }
 
+    /// A turned Full Camera section from 1 s to 9 s: the plan carries the cover strength, full in
+    /// the hold after the start and zero in the steady part.
+    #[test]
+    fn the_frame_plan_carries_the_cover() {
+        let cfg = crate::config::all().pop().expect("cfg");
+        let json = zoomed_golden_scene_json().replace(
+            r#""zoomRegions":[{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.3,"rotation":"none"}]"#,
+            r#""zoomRegions":[],"cameraFullscreenRegions":[{"clipIndex":0,"startSec":1.0,"endSec":9.0,"rotation":180,"fullFrame":true}]"#,
+        );
+        let scene = Scene::from_json(&json).expect("scene");
+        let cover_at = |t: f32| {
+            plan_frame(&FrameGeometryInput { timeline_t_override: Some(t), ..golden_input(&scene, &cfg) })
+                .webcam_cover
+        };
+        assert_eq!(cover_at(1.5), 1.0);
+        assert_eq!(cover_at(5.0), 0.0);
+    }
+
+    /// The desk label's opacity at the compositor caller boundary, against the cover of the same
+    /// frame plan: equal at every sampled frame, and the label (spanned over its whole section by
+    /// the app) is on screen wherever the cover is not 0. Three sections: the review's 2.6 s one
+    /// at 1×, where the label's old fade (from its own 1.15 s window) was half gone while the
+    /// cover still held 1; a long one; and a section inside a 2× speed region, whose cover runs
+    /// on the screen clock.
+    #[test]
+    fn the_desk_label_fades_with_the_cover() {
+        use crate::text_anim::{annotation_text_state, DESK_COVER_ANIMATION};
+        let cfg = crate::config::all().pop().expect("cfg");
+        let zoom = r#""zoomRegions":[{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.3,"rotation":"none"}]"#;
+        let section = |start: f32, end: f32, speed: Option<&str>| {
+            let regions = format!(
+                r#""zoomRegions":[],"cameraFullscreenRegions":[{{"clipIndex":0,"startSec":{start},"endSec":{end},"rotation":180,"fullFrame":true}}]{}"#,
+                speed.map(|s| format!(",{s}")).unwrap_or_default()
+            );
+            Scene::from_json(&zoomed_golden_scene_json().replace(zoom, &regions)).expect("scene")
+        };
+        // (label, cover) at source time `t` of a label spanning [start, end].
+        let sample = |scene: &Scene, start: f32, end: f32, t: f32| {
+            let g = plan_frame(&FrameGeometryInput {
+                timeline_t_override: Some(t),
+                ..golden_input(scene, &cfg)
+            });
+            let label = annotation_text_state(
+                Some(DESK_COVER_ANIMATION),
+                (t - start) * 1000.0,
+                (end - start) * 1000.0,
+                g.webcam_cover,
+            );
+            (label.opacity, g.webcam_cover)
+        };
+        let speed = r#""speedRegions":[{"clipIndex":0,"startSec":1.0,"endSec":9.0,"speed":2.0}]"#;
+        let cases = [
+            ("2.6 s at 1x", section(1.0, 3.6, None), 1.0f32, 3.6f32),
+            ("long at 1x", section(1.0, 9.0, None), 1.0, 9.0),
+            ("2.6 s on screen inside 2x", section(2.0, 7.2, Some(speed)), 2.0, 7.2),
+        ];
+        for (name, scene, start, end) in &cases {
+            let mut t = start - 0.1;
+            while t < end + 0.1 {
+                let (label, cover) = sample(scene, *start, *end, t);
+                assert_eq!(label, cover, "{name}: t = {t}");
+                if cover > 0.0 {
+                    assert!(t >= *start && t < *end, "{name}: cover {cover} outside the label at {t}");
+                }
+                t += 1.0 / 120.0;
+            }
+        }
+        // The review's frames: the cover still holds 1 at 0.9 s and 1.0 s (the old label was at
+        // ~0.5 and below). The 0.28 s left between the holds is two 0.14 s fades meeting at
+        // +1.1575 s, where label and cover touch 0 together before rising into the end hold.
+        let (_, short, s0, s1) = &cases[0];
+        for at in [0.5, 0.9, 1.0] {
+            assert_eq!(sample(short, *s0, *s1, s0 + at), (1.0, 1.0), "at +{at} s");
+        }
+        let (mid, _) = sample(short, *s0, *s1, s0 + 1.09);
+        assert!(mid > 0.0 && mid < 1.0, "mid-fade {mid}");
+        let (low, low_cover) = sample(short, *s0, *s1, s0 + 1.1575);
+        assert!(low < 1e-3 && low == low_cover, "junction {low} vs {low_cover}");
+        assert_eq!(sample(short, *s0, *s1, s1 - 1.25), (1.0, 1.0), "end hold");
+        // Inside 2x the same 2.6 s of screen time takes 5.2 s of source: every screen instant
+        // matches the 1x section's, which the source-time label could not do.
+        let (_, fast, f0, f1) = &cases[2];
+        for k in 0..=26 {
+            let screen = k as f32 * 0.1;
+            let slow = sample(short, *s0, *s1, s0 + screen);
+            let quick = sample(fast, *f0, *f1, f0 + 2.0 * screen);
+            assert!((slow.0 - quick.0).abs() < 1e-3, "screen +{screen} s: {slow:?} vs {quick:?}");
+        }
+    }
+
     /// Le pivot doit rester collé à `center` quand le sprite grandit — c'est exactement ce qui
     /// était cassé (ancrage centré en dur : la pointe s'éloignait proportionnellement à la
     /// taille). On dessine la même flèche à deux tailles et on vérifie que le point désigné
@@ -7730,6 +7863,8 @@ mod tests {
             w_px: [0.0, 0.0],
             w_radius: 0.0,
             shape_fade: 0.0,
+            webcam: WebcamOrientation::default(),
+            webcam_cover: 0.0,
             window_frame: None,
             screen_mask: None,
         }
@@ -8794,4 +8929,110 @@ mod tests {
         println!("left ×2 : {:.3} côté proche, {:.3} côté lointain", near / at_focus, far / at_focus);
         assert!(near > 1.04 * at_focus && far < 0.96 * at_focus, "{near} {at_focus} {far}");
     }
+
+    use crate::scene::SceneCameraFullscreenRegion;
+
+    fn cam_region(rotation: u16, mirror: Option<bool>) -> SceneCameraFullscreenRegion {
+        SceneCameraFullscreenRegion {
+            clip_index: None,
+            start_sec: 0.0,
+            end_sec: 1.0,
+            rotation,
+            mirror,
+            full_frame: rotation == 180,
+        }
+    }
+
+    #[test]
+    fn without_a_region_the_webcam_is_laid_as_before() {
+        for m in [false, true] {
+            assert_eq!(
+                webcam_orientation(None, m),
+                WebcamOrientation { flip_u: m, flip_v: false, full_frame: false }
+            );
+        }
+    }
+
+    /// 180° is both axes swapped; a mirror on top cancels the horizontal one.
+    #[test]
+    fn a_turned_region_swaps_both_axes_and_a_mirror_cancels_one() {
+        let turned = cam_region(180, Some(false));
+        assert_eq!(
+            webcam_orientation(Some(&turned), true),
+            WebcamOrientation { flip_u: true, flip_v: true, full_frame: true }
+        );
+        let turned_mirrored = cam_region(180, Some(true));
+        assert_eq!(
+            webcam_orientation(Some(&turned_mirrored), false),
+            WebcamOrientation { flip_u: false, flip_v: true, full_frame: true }
+        );
+    }
+
+    #[test]
+    fn a_plain_region_keeps_the_layout_mirror_and_an_unknown_rotation_is_none() {
+        assert!(webcam_orientation(Some(&cam_region(0, None)), true).flip_u);
+        let odd = cam_region(90, None);
+        assert_eq!(
+            webcam_orientation(Some(&odd), false),
+            WebcamOrientation { flip_u: false, flip_v: false, full_frame: false }
+        );
+    }
+
+    /// `layer.wgsl` is only compiled on Linux, in CI, where a name or syntax error breaks every
+    /// draw. Parse and validate it on every host through wgpu's own naga, and pin the desk-view
+    /// cover: the fragment entry point must call the radius-taking blur kernel, and the kernel
+    /// must keep its taps inside the picture's valid area.
+    ///
+    /// The file does not declare `LAYER_MODELS`: `compositor_linux::layer_source` prefixes it,
+    /// once per pipeline. Both variants are checked here the same way, the one without the 3D
+    /// models first, since that is the pipeline the webcam (mode 0) is drawn with.
+    #[test]
+    fn layer_wgsl_validates_and_its_fragment_applies_the_desk_view_cover() {
+        use wgpu::naga;
+        fn calls(block: &naga::Block, target: naga::Handle<naga::Function>) -> usize {
+            block
+                .iter()
+                .map(|st| match st {
+                    naga::Statement::Call { function, .. } => usize::from(*function == target),
+                    naga::Statement::Block(b) => calls(b, target),
+                    naga::Statement::If { accept, reject, .. } => calls(accept, target) + calls(reject, target),
+                    naga::Statement::Loop { body, continuing, .. } => calls(body, target) + calls(continuing, target),
+                    naga::Statement::Switch { cases, .. } => cases.iter().map(|c| calls(&c.body, target)).sum(),
+                    _ => 0,
+                })
+                .sum()
+        }
+
+        for models in [false, true] {
+            // The same prefix as `compositor_linux::layer_source`, which only builds on Linux.
+            let source =
+                format!("const LAYER_MODELS: bool = {models};\n{}", include_str!("vk_shaders/layer.wgsl"));
+            let module = naga::front::wgsl::parse_str(&source)
+                .unwrap_or_else(|e| panic!("layer.wgsl (LAYER_MODELS = {models}) parses: {e:?}"));
+            naga::valid::Validator::new(naga::valid::ValidationFlags::all(), naga::valid::Capabilities::all())
+                .validate(&module)
+                .unwrap_or_else(|e| panic!("layer.wgsl (LAYER_MODELS = {models}) validates: {e:?}"));
+            let (kernel, f) = module
+                .functions
+                .iter()
+                .find(|(_, f)| f.name.as_deref() == Some("blur_webcam_radius"))
+                .expect("blur_webcam_radius exists");
+            assert_eq!(f.arguments.len(), 5, "uv, max_r_px, qpx, local_px, valid");
+            // The taps are clamped to the valid part of an aligned decoder texture, half a texel
+            // in: the kernel reads the texture size to know what half a texel is.
+            assert!(
+                f.expressions.iter().any(|(_, e)| matches!(
+                    e,
+                    naga::Expression::ImageQuery { query: naga::ImageQuery::Size { .. }, .. }
+                )),
+                "blur_webcam_radius reads the texture size for its half-texel clamp"
+            );
+            let fs = module.entry_points.iter().find(|e| e.name == "fs_main").expect("fs_main");
+            assert_eq!(
+                calls(&fs.function.body, kernel),
+                1,
+                "fs_main blurs the covered camera once (LAYER_MODELS = {models})"
+            );
+        }
+    }
 }
diff --git a/crates/compositor/src/regions.rs b/crates/compositor/src/regions.rs
index d14c37773..c00cc4d83 100644
--- a/crates/compositor/src/regions.rs
+++ b/crates/compositor/src/regions.rs
@@ -1042,6 +1042,65 @@ pub fn camera_fullscreen_shape_at(
     1.0 - smoothstep(0.5, 1.0, camera_fullscreen_phase_at(regions, t, clock))
 }
 
+/// The Full Camera region in effect at `t`: the one with the strongest phase, so a region's
+/// orientation and its grow/shrink always refer to the same region. `None` wherever the
+/// envelope is 0 — outside every region and on their bounds.
+pub fn camera_fullscreen_region_at<'a>(
+    regions: &'a [SceneCameraFullscreenRegion],
+    t: f32,
+    clock: &ScreenClock,
+) -> Option<&'a SceneCameraFullscreenRegion> {
+    let mut best: Option<(&'a SceneCameraFullscreenRegion, f32)> = None;
+    for r in regions {
+        let phase = camera_fullscreen_region_phase(r, t, clock);
+        if phase > 0.0 && best.map_or(true, |(_, b)| phase > b) {
+            best = Some((r, phase));
+        }
+    }
+    best.map(|(r, _)| r)
+}
+
+/// How long a turned section's camera takes to sharpen after the hold, and to blur again
+/// before the shrink. See `camera_fullscreen_cover_at`.
+pub const DESK_COVER_FADE_S: f32 = 0.5;
+
+/// Cover strength of the webcam at `t` (0 = sharp, 1 = fully blurred and dimmed). Only a
+/// turned section (a camera tilted onto the desk) is covered: the camera is moving at both
+/// ends of such a section, so the picture is hidden for exactly the grow and the shrink, plus a
+/// short fade into and out of the steady part. Measured on screen time like the grow, and 0
+/// on and outside the bounds like the grow.
+pub fn camera_fullscreen_cover_at(
+    regions: &[SceneCameraFullscreenRegion],
+    t: f32,
+    clock: &ScreenClock,
+) -> f32 {
+    let Some(r) = camera_fullscreen_region_at(regions, t, clock) else {
+        return 0.0;
+    };
+    if r.rotation != 180 {
+        return 0.0;
+    }
+    let (start, end, t) = (clock.at(r.start_sec as f32), clock.at(r.end_sec as f32), clock.at(t));
+    // Each hold gets at most half the section; the two fades share what is left, so the start
+    // fade ends at or before the point where the end fade begins and the cover never jumps.
+    let len = end - start;
+    let half = len * 0.5;
+    let hold_in = TRANSITION_WINDOW_S.min(half);
+    let hold_out = FULLSCREEN_LEAD_OUT_WINDOW_S.min(half);
+    let steady = (len - hold_in - hold_out).max(0.0);
+    let fade = DESK_COVER_FADE_S.min(steady * 0.5);
+    let side = |since: f32, hold: f32, fade: f32| -> f32 {
+        if since <= hold {
+            1.0
+        } else if fade > 0.0 && since < hold + fade {
+            1.0 - smoothstep(0.0, fade, since - hold)
+        } else {
+            0.0
+        }
+    };
+    side(t - start, hold_in, fade).max(side(end - t, hold_out, fade))
+}
+
 // ============ Rotation 3D (tilt perspective, présets iso/left/right) ================
 // Port de `computeRotation3DContainScale` (TS, `types.ts`) — même formule, même ordre de
 // composition ("CSS rotateX rotateY rotateZ s'applique droite-à-gauche : Z d'abord, puis Y,
@@ -1977,6 +2036,9 @@ mod zoom_focus_tests {
                 clip_index: None,
                 start_sec: 18.0 * k,
                 end_sec: 22.0 * k,
+                rotation: 0,
+                mirror: None,
+                full_frame: false,
             }]
         };
         let (sped, plain) = (zooms(4.0), zooms(1.0));
@@ -2003,11 +2065,160 @@ mod zoom_focus_tests {
         }
     }
 
+    fn cam(start: f64, end: f64, rotation: u16) -> SceneCameraFullscreenRegion {
+        SceneCameraFullscreenRegion {
+            clip_index: None,
+            start_sec: start,
+            end_sec: end,
+            rotation,
+            mirror: None,
+            full_frame: rotation != 0,
+        }
+    }
+
+    /// Orientation and transition must name the same region: inside it the region, at its
+    /// bounds and outside nothing, exactly where the progress envelope is 0.
+    #[test]
+    fn the_full_camera_region_at_t_is_the_one_the_envelope_uses() {
+        let r = [cam(10.0, 20.0, 180), cam(30.0, 40.0, 0)];
+        let clock = ScreenClock::default();
+        assert_eq!(camera_fullscreen_region_at(&r, 15.0, &clock).map(|c| c.rotation), Some(180));
+        assert_eq!(camera_fullscreen_region_at(&r, 35.0, &clock).map(|c| c.rotation), Some(0));
+        for t in [5.0, 10.0, 20.0, 25.0] {
+            assert!(camera_fullscreen_region_at(&r, t, &clock).is_none(), "t={t}");
+            assert_eq!(camera_fullscreen_progress_at(&r, t, &clock), 0.0, "t={t}");
+        }
+    }
+
+
+    /// The hold covers exactly the grow; then the picture sharpens over the fade.
+    #[test]
+    fn a_turned_section_is_covered_while_the_camera_moves() {
+        let r = [cam(10.0, 30.0, 180)];
+        let clock = ScreenClock::default();
+        let c = |t: f32| camera_fullscreen_cover_at(&r, t, &clock);
+        assert_eq!(c(10.0 + 0.01), 1.0, "start of the hold");
+        assert_eq!(c(10.0 + TRANSITION_WINDOW_S - 0.01), 1.0, "end of the hold");
+        let mid_fade = c(10.0 + TRANSITION_WINDOW_S + DESK_COVER_FADE_S / 2.0);
+        assert!((mid_fade - 0.5).abs() < 1e-3, "half way through the fade: {mid_fade}");
+        assert_eq!(c(20.0), 0.0, "steady part is sharp");
+        // Mirrored at the end: fade up, then hold for the whole shrink.
+        let mid_rise = c(30.0 - FULLSCREEN_LEAD_OUT_WINDOW_S - DESK_COVER_FADE_S / 2.0);
+        assert!((mid_rise - 0.5).abs() < 1e-3, "half way up: {mid_rise}");
+        assert_eq!(c(30.0 - FULLSCREEN_LEAD_OUT_WINDOW_S + 0.01), 1.0);
+        assert_eq!(c(30.0 - 0.01), 1.0);
+    }
+
+    #[test]
+    fn the_cover_is_zero_on_and_outside_the_bounds() {
+        let r = [cam(10.0, 30.0, 180)];
+        let clock = ScreenClock::default();
+        for t in [0.0, 9.99, 10.0, 30.0, 30.01, 40.0] {
+            assert_eq!(camera_fullscreen_cover_at(&r, t, &clock), 0.0, "t={t}");
+        }
+    }
+
+    #[test]
+    fn a_plain_section_is_never_covered() {
+        let r = [cam(10.0, 30.0, 0)];
+        let clock = ScreenClock::default();
+        for step in 0..=400 {
+            let t = step as f32 * 0.1;
+            assert_eq!(camera_fullscreen_cover_at(&r, t, &clock), 0.0, "t={t}");
+        }
+    }
+
+    /// Each hold gets at most half the section and the fades share what is left, so a section
+    /// shorter than both holds is covered throughout and a longer one keeps its full fades.
+    #[test]
+    fn short_sections_shrink_the_fades_first() {
+        let clock = ScreenClock::default();
+        let short = [cam(10.0, 11.5, 180)]; // half = 0.75 < hold-in: no fade at all
+        for step in 1..150 {
+            let t = 10.0 + step as f32 * 0.01;
+            let c = camera_fullscreen_cover_at(&short, t, &clock);
+            assert!((0.0..=1.0).contains(&c), "t={t}: {c}");
+            assert_eq!(c, 1.0, "a section shorter than both holds is covered throughout (t={t})");
+        }
+        // 3.6 s: steady = 3.6 - 1.015 - 1.523 = 1.06, so both ends keep their full 0.5 s fade.
+        let medium = [cam(10.0, 13.6, 180)];
+        let c = |t: f32| camera_fullscreen_cover_at(&medium, t, &clock);
+        let mid_fade = c(10.0 + TRANSITION_WINDOW_S + DESK_COVER_FADE_S / 2.0);
+        assert!((mid_fade - 0.5).abs() < 1e-3, "start fade half way: {mid_fade}");
+        let mid_rise = c(13.6 - FULLSCREEN_LEAD_OUT_WINDOW_S - DESK_COVER_FADE_S / 2.0);
+        assert!((mid_rise - 0.5).abs() < 1e-3, "end fade half way: {mid_rise}");
+    }
+
+    /// 2.6 s: hold-in 1.015, hold-out 1.3 (half), steady 0.285 — the two fades share it,
+    /// 0.1425 s each, so the start fade ends exactly where the end fade begins.
+    #[test]
+    fn medium_sections_share_the_steady_part_between_the_fades() {
+        let clock = ScreenClock::default();
+        let r = [cam(10.0, 12.6, 180)];
+        let c = |t: f32| camera_fullscreen_cover_at(&r, t, &clock);
+        let fade = (2.6 - TRANSITION_WINDOW_S - 1.3) / 2.0;
+        let meet = 10.0 + TRANSITION_WINDOW_S + fade;
+        let mid_fade = c(10.0 + TRANSITION_WINDOW_S + fade / 2.0);
+        assert!((mid_fade - 0.5).abs() < 1e-2, "start fade half way: {mid_fade}");
+        assert!(c(meet) < 1e-2, "both fades are near zero where they meet: {}", c(meet));
+        let mid_rise = c(12.6 - 1.3 - fade / 2.0);
+        assert!((mid_rise - 0.5).abs() < 1e-2, "end fade half way: {mid_rise}");
+        assert_eq!(c(12.6 - 1.3 + 0.01), 1.0, "the end hold is half the section");
+    }
+
+    /// No section length makes the cover jump: sampled every 1 ms, no step exceeds 0.1. (At
+    /// 10 ms the shortest legitimate fade — 42 ms in a 2.2 s section — already steps ~0.3 per
+    /// sample, so the finer grid is what tells a ramp from a jump.)
+    #[test]
+    fn the_cover_is_continuous_for_every_section_length() {
+        let clock = ScreenClock::default();
+        for len in [2.0_f32, 2.2, 2.6, 3.0, 3.5, 4.0, 4.5] {
+            let r = [cam(10.0, 10.0 + len as f64, 180)];
+            let steps = (len * 1000.0).round() as i32;
+            let mut prev = camera_fullscreen_cover_at(&r, 10.0 + 0.0005, &clock);
+            for step in 1..steps {
+                let t = 10.0 + step as f32 * 0.001;
+                let c = camera_fullscreen_cover_at(&r, t, &clock);
+                assert!((0.0..=1.0).contains(&c), "len={len} t={t}: {c}");
+                assert!((c - prev).abs() <= 0.1, "len={len} t={t}: {prev} -> {c}");
+                prev = c;
+            }
+        }
+    }
+
+    /// Under a speed change the windows are measured on screen time, like the grow.
+    #[test]
+    fn the_cover_runs_on_screen_time() {
+        let clock = ScreenClock::new(&[speed(None, 0.0, 1000.0, 2.0)], 0);
+        let r = [cam(10.0, 40.0, 180)];
+        // At 2x, the 1.015 s hold spans 2.03 s of source time.
+        assert_eq!(camera_fullscreen_cover_at(&r, 10.0 + 1.9, &clock), 1.0);
+        assert!(camera_fullscreen_cover_at(&r, 10.0 + 3.6, &clock) < 1.0);
+    }
+    #[test]
+    fn the_region_fields_parse_and_default() {
+        let plain: SceneCameraFullscreenRegion =
+            serde_json::from_str(r#"{"startSec":1,"endSec":2}"#).unwrap();
+        assert_eq!((plain.rotation, plain.mirror, plain.full_frame), (0, None, false));
+        let desk: SceneCameraFullscreenRegion = serde_json::from_str(
+            r#"{"startSec":1,"endSec":2,"rotation":180,"mirror":false,"fullFrame":true}"#,
+        )
+        .unwrap();
+        assert_eq!((desk.rotation, desk.mirror, desk.full_frame), (180, Some(false), true));
+    }
+
     /// Les coins suivent la phase, pas le rect. Avec `1 - progrès`, ils étaient carrés presque
     /// tout du long de la montée et ne revenaient qu'à la toute fin du retour.
     #[test]
     fn full_camera_corners_dissolve_late_and_come_back_early() {
-        let r = [SceneCameraFullscreenRegion { clip_index: None, start_sec: 10.0, end_sec: 20.0 }];
+        let r = [SceneCameraFullscreenRegion {
+            clip_index: None,
+            start_sec: 10.0,
+            end_sec: 20.0,
+            rotation: 0,
+            mirror: None,
+            full_frame: false,
+        }];
         let clock = ScreenClock::default();
         let at = |t: f32| {
             (camera_fullscreen_progress_at(&r, t, &clock), camera_fullscreen_shape_at(&r, t, &clock))
diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs
index bddd7d55c..a7ca6c13a 100644
--- a/crates/compositor/src/scene.rs
+++ b/crates/compositor/src/scene.rs
@@ -528,7 +528,8 @@ pub struct SceneSpeedRegion {
 
 /// Une zone "Full Camera" de la timeline (temps en secondes) : la caméra PREND tout le cadre
 /// pendant cette fenêtre (plein écran net — ni marge, ni arrondi, ni masque, ni fond derrière).
-/// Pas de champs au-delà des bornes temporelles (miroir de `CameraFullscreenRegion`, TS).
+/// The orientation fields are resolved by the app (`sceneDescription.ts`): a desk shot
+/// arrives as `rotation: 180`, `mirror: false`, `fullFrame: true`.
 #[derive(Debug, Clone, Copy, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SceneCameraFullscreenRegion {
@@ -537,6 +538,15 @@ pub struct SceneCameraFullscreenRegion {
     pub clip_index: Option<usize>,
     pub start_sec: f64,
     pub end_sec: f64,
+    /// 0 or 180. Anything else is treated as 0 by `frame_geometry::webcam_orientation`.
+    #[serde(default)]
+    pub rotation: u16,
+    /// Mirror inside this region; `None` = the layout's `webcam_mirror`.
+    #[serde(default)]
+    pub mirror: Option<bool>,
+    /// Ignore `layout.webcam_crop` inside this region.
+    #[serde(default)]
+    pub full_frame: bool,
 }
 
 /// Rendu du curseur.
diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlsl
index c17d207d9..8e1b1bc2a 100644
--- a/crates/compositor/src/shaders.hlsl
+++ b/crates/compositor/src/shaders.hlsl
@@ -23,6 +23,7 @@ cbuffer Layer : register(b0)
     float4 trail_a;   // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx) ; mode 18 incliné : en fractions de sortie
     float4 trail_b;   // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortie
     float4 trail_mb;  // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; mode 18 incliné : le `mb` du mode 8 (profondeur de champ), et `color.xy` sa lampe ; 0 ailleurs
+    float4 cover;     // x = desk-view cover 0..1, y = blur radius (quad px), z = dim, w unused
 };
 // Mode 15 (curseur modélisé) : le détail des emplacements est dans `frame_geometry.rs`, en tête
 // de la section « Curseur modélisé » (`cursor_model_cb`). Mode 17 (appareil modelé) : en tête de
@@ -502,10 +503,15 @@ static const float3 VOGEL_TAPS[21] = {
     float3(-0.633036, -0.758588, 0.087119)
 };
 
-float3 blur_webcam_bg(float2 uv, float intensity, float2 qpx, float2 local_px)
+// Vogel-disc blur of the camera texture at a radius in quad pixels. `valid` is the part of the
+// texture the picture fills (fx.xy): decoders allocate aligned textures (a 1080-line camera in a
+// 1088-line texture), so each tap is clamped half a chroma texel inside it, never into padding.
+float3 blur_webcam_radius(float2 uv, float max_r_px, float2 qpx, float2 local_px, float2 valid)
 {
-    float max_r_px = max(intensity, 0.0) * 22.0 + 1.5;
     float2 step = max_r_px / max(qpx, 1.0);
+    float cw, ch;
+    texUV.GetDimensions(cw, ch);
+    float2 hi = max(valid - 0.5 / max(float2(cw, ch), 1.0), 0.0);
     // Interleaved Gradient Noise pour rotation aléatoire par pixel
     float noise = frac(52.9829189 * frac(0.06711056 * local_px.x + 0.00583715 * local_px.y));
     float angle = noise * 6.2831853;
@@ -518,12 +524,17 @@ float3 blur_webcam_bg(float2 uv, float intensity, float2 qpx, float2 local_px)
         float2 p = VOGEL_TAPS[k].xy;
         float w = VOGEL_TAPS[k].z;
         float2 rot_p = float2(p.x * c - p.y * s, p.x * s + p.y * c);
-        sum += sample_yuv(saturate(uv + rot_p * step)) * w;
+        sum += sample_yuv(clamp(uv + rot_p * step, 0.0, hi)) * w;
         total += w;
     }
     return sum / max(total, 1e-4);
 }
 
+float3 blur_webcam_bg(float2 uv, float intensity, float2 qpx, float2 local_px, float2 valid)
+{
+    return blur_webcam_radius(uv, max(intensity, 0.0) * 22.0 + 1.5, qpx, local_px, valid);
+}
+
 // ============ Curseur MODÉLISÉ (mode 15) ============
 // L'état courant en objet 3D, lancé de rayons par pixel. Deux sortes d'objets :
 // - un curseur SCULPTÉ (`trail_a.x` > 0) : la flèche ou la main d'un des cinq thèmes d'origine,
@@ -4028,13 +4039,21 @@ float4 ps_main(VSOut i) : SV_Target
             }
             else if (effect > 1.5)
             {
-                rgb = lerp(blur_webcam_bg(uv_now, fx.w, quad_px, i.local), rgb, person);
+                rgb = lerp(blur_webcam_bg(uv_now, fx.w, quad_px, i.local, fx.xy), rgb, person);
             }
             else
             {
                 alpha_mask = person;
             }
         }
+
+        // Desk-view cover: the camera is being tilted, so the whole picture is blurred and
+        // dimmed (cover.x = strength, cover.y = radius in quad px, cover.z = dim at full cover).
+        if (cover.x > 0.001)
+        {
+            float3 hidden = blur_webcam_radius(uv_now, cover.y, quad_px, i.local, fx.xy);
+            rgb = lerp(rgb, hidden, cover.x) * (1.0 - cover.z * cover.x);
+        }
     }
     else
     {
diff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metal
index 7ca87d3f2..baf787b1c 100644
--- a/crates/compositor/src/shaders.metal
+++ b/crates/compositor/src/shaders.metal
@@ -48,7 +48,7 @@ using namespace metal;
 // =================================================================================
 //
 // Le moteur côté CPU upload ce buffer via `setVertexBytes` (vertex stage) et
-// `setFragmentBytes` (fragment stage) avant chaque draw — la copie est de 176 octets,
+// `setFragmentBytes` (fragment stage) avant chaque draw — la copie est de 192 octets,
 // ce qui est sous le seuil d'alignement 4K de Metal pour le mode « immediate ».
 
 struct Layer
@@ -66,6 +66,7 @@ struct Layer
     float4 trail_a;   // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx) ; mode 18 incliné : en fractions de sortie
     float4 trail_b;   // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortie
     float4 trail_mb;  // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; 0 ailleurs
+    float4 cover;     // x = desk-view cover 0..1, y = blur radius (quad px), z = dim, w unused
 };
 // Mode 15 (curseur modélisé) : le détail des emplacements est dans `frame_geometry.rs`, en tête
 // de la section « Curseur modélisé » (`cursor_model_cb`). Mode 17 (appareil modelé) : en tête de
@@ -424,12 +425,17 @@ constant float3 VOGEL_TAPS[21] = {
     float3(-0.633036, -0.758588, 0.087119)
 };
 
-inline float3 blur_webcam_bg(float2 uv, float intensity, float2 qpx, float2 local_px,
-                             texture2d<float, access::sample> texY,
-                             texture2d<float, access::sample> texUV)
+// Vogel-disc blur of the camera texture at a radius in quad pixels. `valid` is the part of the
+// texture the picture fills (fx.xy): decoders allocate aligned textures (a 1080-line camera in a
+// 1088-line texture), so each tap is clamped half a chroma texel inside it, never into padding.
+inline float3 blur_webcam_radius(float2 uv, float max_r_px, float2 qpx, float2 local_px,
+                                 float2 valid,
+                                 texture2d<float, access::sample> texY,
+                                 texture2d<float, access::sample> texUV)
 {
-    float max_r_px = max(intensity, 0.0) * 22.0 + 1.5;
     float2 step = max_r_px / max(qpx, float2(1.0));
+    float2 chroma = max(float2(float(texUV.get_width()), float(texUV.get_height())), float2(1.0));
+    float2 hi = max(valid - 0.5 / chroma, float2(0.0));
     float noise = fract(52.9829189 * fract(0.06711056 * local_px.x + 0.00583715 * local_px.y));
     float angle = noise * 6.2831853;
     float s = sin(angle);
@@ -441,12 +447,21 @@ inline float3 blur_webcam_bg(float2 uv, float intensity, float2 qpx, float2 loca
         float2 p = VOGEL_TAPS[k].xy;
         float w = VOGEL_TAPS[k].z;
         float2 rot_p = float2(p.x * c - p.y * s, p.x * s + p.y * c);
-        sum += sample_yuv(saturate(uv + rot_p * step), texY, texUV) * w;
+        sum += sample_yuv(clamp(uv + rot_p * step, float2(0.0), hi), texY, texUV) * w;
         total += w;
     }
     return sum / max(total, 1e-4);
 }
 
+inline float3 blur_webcam_bg(float2 uv, float intensity, float2 qpx, float2 local_px,
+                             float2 valid,
+                             texture2d<float, access::sample> texY,
+                             texture2d<float, access::sample> texUV)
+{
+    return blur_webcam_radius(uv, max(intensity, 0.0) * 22.0 + 1.5, qpx, local_px, valid, texY,
+                              texUV);
+}
+
 // Hash 2D -> [0,1) sans sin(). Miroir de `hash12` côté HLSL.
 inline float hash12(float2 p)
 {
@@ -3772,13 +3787,22 @@ fragment float4 ps_main(VSOut i [[stage_in]],
             }
             else if (effect > 1.5)
             {
-                rgb = mix(blur_webcam_bg(uv_now, layer.fx.w, layer.quad_px, i.local, texY, texUV), rgb, person);
+                rgb = mix(blur_webcam_bg(uv_now, layer.fx.w, layer.quad_px, i.local, layer.fx.xy, texY, texUV), rgb, person);
             }
             else
             {
                 alpha_mask = person;
             }
         }
+
+        // Desk-view cover: the camera is being tilted, so the whole picture is blurred and
+        // dimmed (cover.x = strength, cover.y = radius in quad px, cover.z = dim at full cover).
+        if (layer.cover.x > 0.001)
+        {
+            float3 hidden = blur_webcam_radius(uv_now, layer.cover.y, layer.quad_px, i.local, layer.fx.xy,
+                                               texY, texUV);
+            rgb = mix(rgb, hidden, layer.cover.x) * (1.0 - layer.cover.z * layer.cover.x);
+        }
     }
     else
     {
diff --git a/crates/compositor/src/text_anim.rs b/crates/compositor/src/text_anim.rs
index d6d3bade1..ae3887f98 100644
--- a/crates/compositor/src/text_anim.rs
+++ b/crates/compositor/src/text_anim.rs
@@ -4,7 +4,8 @@
 //! amplitudes. Les sept animations étaient déjà nommées dans le schéma, traduites dans les treize
 //! langues et transportées jusqu'ici par la scène — mais rien ne les jouait. Reprendre les
 //! constantes du TS plutôt que d'en réinventer garantit qu'un projet fait à l'époque de l'aperçu
-//! DOM s'anime toujours pareil.
+//! DOM s'anime toujours pareil. Exception : l'étiquette de la vue bureau (`deskCover`), que seul
+//! le compositeur joue et qui n'a pas de courbe propre (cf. `annotation_text_state`).
 
 /// Les décalages ci-dessous sont exprimés en px À CETTE HAUTEUR : l'appelant les met à l'échelle
 /// de la sortie, exactement comme la taille de police (cf. `annotationScale.ts`). En pixels
@@ -17,6 +18,10 @@ pub const TEXT_ANIMATION_DURATION_MS: f32 = 700.0;
 /// fin de l'annotation est une coupe sèche alors que son arrivée est animée.
 pub const TEXT_EXIT_DURATION_MS: f32 = 300.0;
 
+/// The desk-view label's animation. The app generates it for a turned Full Camera section and
+/// never stores it in a document, so it exists only here, not in `annotationTextAnimation.ts`.
+pub const DESK_COVER_ANIMATION: &str = "deskCover";
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct TextAnimationState {
     pub opacity: f32,
@@ -37,6 +42,11 @@ fn clamp01(v: f32) -> f32 {
     v.clamp(0.0, 1.0)
 }
 
+fn smoothstep01(v: f32) -> f32 {
+    let t = clamp01(v);
+    t * t * (3.0 - 2.0 * t)
+}
+
 fn ease_out_cubic(v: f32) -> f32 {
     let t = clamp01(v);
     1.0 - (1.0 - t).powi(3)
@@ -106,6 +116,30 @@ pub fn text_animation_state(
     }
 }
 
+/// `true` for the desk-view label, whose opacity is the camera cover (`annotation_text_state`).
+pub fn is_desk_cover(animation: Option<&str>) -> bool {
+    animation == Some(DESK_COVER_ANIMATION)
+}
+
+/// What the compositors draw a text annotation with. Ordinary animations run on
+/// `text_animation_state` (source time, unchanged). The desk-view label has no timing of its
+/// own: its opacity IS `cover`, the webcam's cover strength this frame
+/// (`camera_fullscreen_cover_at`, already on the screen clock). A second fade derived from the
+/// label's own window drifted from the cover on short sections and inside speed regions; one
+/// value read twice cannot. The app spans the label over its whole section, so the cover alone
+/// decides when it shows.
+pub fn annotation_text_state(
+    animation: Option<&str>,
+    elapsed_ms: f32,
+    region_ms: f32,
+    cover: f32,
+) -> TextAnimationState {
+    if is_desk_cover(animation) {
+        return TextAnimationState { opacity: clamp01(cover), ..TextAnimationState::IDLE };
+    }
+    text_animation_state(animation, elapsed_ms, region_ms)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -245,4 +279,28 @@ mod tests {
     fn an_empty_region_does_not_divide_by_zero() {
         assert!(text_animation_state(Some("fade"), 0.0, 0.0).opacity.is_finite());
     }
+
+    #[test]
+    fn the_desk_label_takes_the_cover_and_nothing_else() {
+        // Whatever the label's own window says, only the cover counts; the motion fields stay idle.
+        for cover in [0.0, 0.21, 0.45, 1.0] {
+            for (elapsed, region) in [(0.0, 2600.0), (900.0, 1150.0), (5000.0, LONG)] {
+                let s = annotation_text_state(Some(DESK_COVER_ANIMATION), elapsed, region, cover);
+                assert_eq!(s, TextAnimationState { opacity: cover, ..TextAnimationState::IDLE });
+            }
+        }
+    }
+
+    #[test]
+    fn ordinary_animations_ignore_the_cover() {
+        for name in [None, Some("fade"), Some("rise"), Some("pop"), Some("typewriter"), Some("pulse")] {
+            for at in [0.0, 200.0, 650.0, 9_900.0] {
+                assert_eq!(
+                    annotation_text_state(name, at, LONG, 0.37),
+                    text_animation_state(name, at, LONG),
+                    "{name:?} at {at}"
+                );
+            }
+        }
+    }
 }
diff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgsl
index ecf4960a1..1916cef1f 100644
--- a/crates/compositor/src/vk_shaders/layer.wgsl
+++ b/crates/compositor/src/vk_shaders/layer.wgsl
@@ -40,6 +40,7 @@ struct Layer {
     trail_a: vec4<f32>,   // mode 8 : coins TL, TR du plan a la frame precedente (px locaux, comme fx) ; mode 18 incline : en fractions de sortie
     trail_b: vec4<f32>,   // mode 8 : coins BR, BL du plan a la frame precedente (comme src_prev) ; mode 18 incline : en fractions de sortie
     trail_mb: vec4<f32>,  // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; mode 18 incline : le `mb` du mode 8 (profondeur de champ), et `color.xy` sa lampe ; 0 ailleurs
+    cover: vec4<f32>,     // x = desk-view cover 0..1, y = blur radius (quad px), z = dim, w unused
 }
 
 @group(0) @binding(0) var<uniform> layer: Layer;
@@ -560,9 +561,13 @@ const VOGEL_TAPS = array<vec3<f32>, 21>(
     vec3<f32>(-0.633036, -0.758588, 0.087119)
 );
 
-fn blur_webcam_bg(uv: vec2<f32>, intensity: f32, qpx: vec2<f32>, local_px: vec2<f32>) -> vec3<f32> {
-    let max_r_px = max(intensity, 0.0) * 22.0 + 1.5;
+// Vogel-disc blur of the camera texture at a radius in quad pixels. `valid` is the part of the
+// texture the picture fills (fx.xy): decoders allocate aligned textures (a 1080-line camera in a
+// 1088-line texture), so each tap is clamped half a chroma texel inside it, never into padding.
+fn blur_webcam_radius(uv: vec2<f32>, max_r_px: f32, qpx: vec2<f32>, local_px: vec2<f32>, valid: vec2<f32>) -> vec3<f32> {
     let step = max_r_px / max(qpx, vec2<f32>(1.0));
+    let chroma = max(vec2<f32>(textureDimensions(texU)), vec2<f32>(1.0));
+    let hi = max(valid - 0.5 / chroma, vec2<f32>(0.0));
     let noise = fract(52.9829189 * fract(0.06711056 * local_px.x + 0.00583715 * local_px.y));
     let angle = noise * 6.2831853;
     let s = sin(angle);
@@ -573,12 +578,16 @@ fn blur_webcam_bg(uv: vec2<f32>, intensity: f32, qpx: vec2<f32>, local_px: vec2<
         let p = VOGEL_TAPS[k].xy;
         let w = VOGEL_TAPS[k].z;
         let rot_p = vec2<f32>(p.x * c - p.y * s, p.x * s + p.y * c);
-        sum = sum + sample_yuv(clamp(uv + rot_p * step, vec2<f32>(0.0), vec2<f32>(1.0))) * w;
+        sum = sum + sample_yuv(clamp(uv + rot_p * step, vec2<f32>(0.0), hi)) * w;
         total = total + w;
     }
     return sum / max(total, 1e-4);
 }
 
+fn blur_webcam_bg(uv: vec2<f32>, intensity: f32, qpx: vec2<f32>, local_px: vec2<f32>, valid: vec2<f32>) -> vec3<f32> {
+    return blur_webcam_radius(uv, max(intensity, 0.0) * 22.0 + 1.5, qpx, local_px, valid);
+}
+
 // ---- Curseur MODELISE (mode 15) ----
 // Port ligne pour ligne de `cursor_model` (HLSL), dont les commentaires font foi : un curseur
 // SCULPTE (`trail_a.x` > 0, la fleche ou la main d'un des cinq themes d'origine modelee en
@@ -2308,11 +2317,18 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
             if effect > 2.5 {
                 rgb = mix(layer.color.rgb, rgb, person);
             } else if effect > 1.5 {
-                rgb = mix(blur_webcam_bg(i.uv, layer.fx.w, layer.quad_px, i.local), rgb, person);
+                rgb = mix(blur_webcam_bg(i.uv, layer.fx.w, layer.quad_px, i.local, layer.fx.xy), rgb, person);
             } else {
                 alpha_mask = person;
             }
         }
+
+        // Desk-view cover: the camera is being tilted, so the whole picture is blurred and
+        // dimmed (cover.x = strength, cover.y = radius in quad px, cover.z = dim at full cover).
+        if layer.cover.x > 0.001 {
+            let hidden = blur_webcam_radius(i.uv, layer.cover.y, layer.quad_px, i.local, layer.fx.xy);
+            rgb = mix(rgb, hidden, layer.cover.x) * (1.0 - layer.cover.z * layer.cover.x);
+        }
     } else if layer.mode < 1.5 {
         // Mode 1 — couleur pleine.
         rgb = layer.color.rgb;
diff --git a/src/components/ai-edition/NativeCompositorOverlay.test.tsx b/src/components/ai-edition/NativeCompositorOverlay.test.tsx
index ff3522665..7c4c0f397 100644
--- a/src/components/ai-edition/NativeCompositorOverlay.test.tsx
+++ b/src/components/ai-edition/NativeCompositorOverlay.test.tsx
@@ -18,20 +18,23 @@ import { publishNativePosition } from "@/native/nativeSync";
 const native = vi.hoisted(() => ({
 	setActiveClip: vi.fn(async () => ({ ok: true })),
 	setNativePlaying: vi.fn(),
+	setNativeScene: vi.fn(),
 }));
+const i18n = vi.hoisted(() => ({ locale: "en" }));
 
 vi.mock("@/native", () => ({
 	pushAllNativeParams: vi.fn(),
 	setActiveClip: native.setActiveClip,
 	setCurrentNativeViewId: vi.fn(),
 	setNativePlaying: native.setNativePlaying,
-	setNativeScene: vi.fn(),
+	setNativeScene: native.setNativeScene,
 	subscribeNativeCompositor: () => () => undefined,
 	useIsCpuCompositor: () => false,
 	useNativeCompositorView: () => ({ viewId: 7, error: null }),
 }));
 
 vi.mock("@/contexts/I18nContext", () => ({
+	useI18n: () => ({ locale: i18n.locale }),
 	useScopedT: () => (key: string) => key,
 }));
 
@@ -249,3 +252,43 @@ describe("NativeCompositorOverlay while playing", () => {
 		expect(native.setActiveClip).toHaveBeenCalledTimes(1);
 	});
 });
+
+// The desk-view label is generated text inside the scene, so the scene is rebuilt when the
+// user switches language — otherwise the preview keeps the old label until the next edit.
+describe("NativeCompositorOverlay on a language change", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		i18n.locale = "en";
+		useProjectStore.setState({
+			projectId: "proj_sync",
+			document: makeDocument(),
+			revision: 1,
+			status: "ready",
+			error: null,
+			sourceDurationSec: 12,
+			currentTimeSec: 1,
+			playing: false,
+			dirty: false,
+			lastSavedAt: new Date(),
+		});
+	});
+
+	afterEach(() => {
+		cleanup();
+		i18n.locale = "en";
+		useProjectStore.getState().clear();
+	});
+
+	it("pushes the scene again when the locale changes", async () => {
+		const { rerender } = render(<NativeCompositorOverlay />);
+		await act(async () => {
+			await Promise.resolve();
+		});
+		native.setNativeScene.mockClear();
+
+		i18n.locale = "de";
+		rerender(<NativeCompositorOverlay />);
+
+		expect(native.setNativeScene).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/src/components/ai-edition/NativeCompositorOverlay.tsx b/src/components/ai-edition/NativeCompositorOverlay.tsx
index d60bbcd20..f3a90605b 100644
--- a/src/components/ai-edition/NativeCompositorOverlay.tsx
+++ b/src/components/ai-edition/NativeCompositorOverlay.tsx
@@ -1,5 +1,5 @@
 import { useEffect, useMemo, useRef, useSyncExternalStore } from "react";
-import { useScopedT } from "@/contexts/I18nContext";
+import { useI18n, useScopedT } from "@/contexts/I18nContext";
 import { readSpeedRegions } from "@/lib/ai-edition/document/timeline";
 import { noteUiProbeClipSwitch } from "@/lib/ai-edition/perf/uiFrameProbe";
 import { getEditorSettings } from "@/lib/ai-edition/store/editorSettings";
@@ -129,6 +129,8 @@ export function NativeCompositorOverlay() {
 		sources: sources ?? undefined,
 	});
 	const t = useScopedT("editor");
+	// The scene carries translated text (the desk-view label): a language switch rebuilds it.
+	const { locale } = useI18n();
 	// No usable GPU: the preview still renders every effect, just slowly (~8 fps with
 	// everything on). Nothing is disabled — the output stays identical to the GPU path —
 	// so this is a notice, not a degradation warning.
@@ -147,7 +149,7 @@ export function NativeCompositorOverlay() {
 	// `_webcamSizeRevision` ci-dessus) : le layout preset et cie pilotent le rendu (remplace le
 	// layout fixture). Effet APRÈS celui du viewId ci-dessus → currentViewId est déjà publié
 	// quand on pousse.
-	// biome-ignore lint/correctness/useExhaustiveDependencies: size revision
+	// biome-ignore lint/correctness/useExhaustiveDependencies: size revision, locale
 	useEffect(() => {
 		if (viewId === null || !document) {
 			return;
@@ -163,8 +165,9 @@ export function NativeCompositorOverlay() {
 		// re-trigger this effect when the probed-size cache mutates; the actual value is
 		// re-read fresh via getWebcamNativeSize() above on every run (biome flags this as
 		// an "unnecessary" dependency, but removing it would mean a probed webcam size
-		// arriving after mount never gets pushed to native).
-	}, [viewId, document, sources, _webcamSizeRevision]);
+		// arriving after mount never gets pushed to native). `locale` is the same kind of
+		// trigger: the label text is read inside `buildSceneDescription`.
+	}, [viewId, document, sources, _webcamSizeRevision, locale]);
 
 	// SYNCHRO COMPLETE DES PARAMS, en un seul endroit.
 	//
diff --git a/src/components/ai-edition/v4/EditorShellV4.module.css b/src/components/ai-edition/v4/EditorShellV4.module.css
index b4a1449cc..d4bc74c96 100644
--- a/src/components/ai-edition/v4/EditorShellV4.module.css
+++ b/src/components/ai-edition/v4/EditorShellV4.module.css
@@ -599,6 +599,13 @@
 	flex-direction: column;
 	min-height: 0;
 }
+/* A pane button that toggles (Desk view) lights up like the timeline's toggle tools, off
+   aria-pressed. The hover rule keeps it lit: the secondary button's own hover would win. */
+.paneToggle[aria-pressed="true"],
+.paneToggle[aria-pressed="true"]:hover:not(:disabled) {
+	background: var(--accent-soft);
+	color: var(--accent);
+}
 .facetRail {
 	pointer-events: auto;
 	display: flex;
diff --git a/src/components/ai-edition/v4/FloatingInspector.test.tsx b/src/components/ai-edition/v4/FloatingInspector.test.tsx
index 512b2ab18..275b93cbc 100644
--- a/src/components/ai-edition/v4/FloatingInspector.test.tsx
+++ b/src/components/ai-edition/v4/FloatingInspector.test.tsx
@@ -1,5 +1,7 @@
 // @vitest-environment jsdom
 import "@testing-library/jest-dom";
+import { readFileSync } from "node:fs";
+import path from "node:path";
 import {
 	act,
 	fireEvent,
@@ -24,6 +26,7 @@ vi.mock("../RightPanes", async (importOriginal) => ({
 	AudioPane: () => <div data-testid="audio-pane">AudioPane</div>,
 	// The real row: the zoom pane's choices are read and pressed below.
 	ChoiceRow: (await importOriginal<typeof import("../RightPanes")>()).ChoiceRow,
+	Toggle: (await importOriginal<typeof import("../RightPanes")>()).Toggle,
 	AudioTrackPane: ({ onClose }: { onClose?: () => void }) => (
 		<div data-testid="audio-track-pane">
 			AudioTrackPane
@@ -59,6 +62,7 @@ vi.mock("../CaptionsPane", () => ({
 	CaptionsPane: () => <div data-testid="captions-pane">CaptionsPane</div>,
 }));
 
+import styles from "./EditorShellV4.module.css";
 import { AnnotationSizeControl, AnnotationSizeField, FloatingInspector } from "./FloatingInspector";
 
 // The rail's buttons have tooltips, and the app's root provides the provider they need.
@@ -516,6 +520,85 @@ describe("FloatingInspector", () => {
 			vi.unstubAllGlobals();
 		});
 	});
+
+	describe("full camera pane", () => {
+		const camTl = (region: Record<string, unknown>) => {
+			const updateCameraFullscreenOrientation = vi.fn();
+			const updateCameraFullscreenDeskLabel = vi.fn();
+			const tl = {
+				...defaultProps.tl,
+				selection: { kind: "cameraFullscreen", id: "cf" },
+				cameraFullscreenRegions: [{ id: "cf", startMs: 0, endMs: 2000, ...region }],
+				updateCameraFullscreenOrientation,
+				updateCameraFullscreenDeskLabel,
+				removeRegion: vi.fn(),
+			} as unknown as React.ComponentProps<typeof FloatingInspector>["tl"];
+			return { tl, updateCameraFullscreenOrientation, updateCameraFullscreenDeskLabel };
+		};
+
+		it("desk view sets both fields in one call", () => {
+			const { tl, updateCameraFullscreenOrientation } = camTl({});
+			render(<FloatingInspector {...defaultProps} tl={tl} />);
+			const desk = screen.getByRole("button", { name: "settings.cameraFullscreen.deskView" });
+			expect(desk).toHaveAttribute("aria-pressed", "false");
+			fireEvent.click(desk);
+			expect(updateCameraFullscreenOrientation).toHaveBeenCalledTimes(1);
+			expect(updateCameraFullscreenOrientation).toHaveBeenCalledWith("cf", {
+				rotation: 180,
+				mirror: "auto",
+			});
+		});
+
+		it("turns desk view off again in one call", () => {
+			const { tl, updateCameraFullscreenOrientation } = camTl({ rotation: 180 });
+			render(<FloatingInspector {...defaultProps} tl={tl} />);
+			const desk = screen.getByRole("button", { name: "settings.cameraFullscreen.deskView" });
+			expect(desk).toHaveAttribute("aria-pressed", "true");
+			fireEvent.click(desk);
+			expect(updateCameraFullscreenOrientation).toHaveBeenCalledWith("cf", {
+				rotation: 0,
+				mirror: "auto",
+			});
+		});
+
+		// The pane button has no pressed look of its own, so desk view wears a toggle class
+		// whose lit state is styled off aria-pressed — and only that button wears it.
+		it("lights the desk view button off its pressed state", () => {
+			const { tl } = camTl({ rotation: 180 });
+			render(<FloatingInspector {...defaultProps} tl={tl} />);
+			const desk = screen.getByRole("button", { name: "settings.cameraFullscreen.deskView" });
+			expect(styles.paneToggle).toBeTruthy();
+			expect(desk.classList).toContain(styles.paneToggle);
+			expect(document.querySelectorAll(`.${styles.paneToggle}`)).toHaveLength(1);
+			const css = readFileSync(path.join(__dirname, "EditorShellV4.module.css"), "utf8");
+			expect(css).toMatch(/\.paneToggle\[aria-pressed="true"\]\s*[,{]/);
+		});
+
+		it("offers the label switch only on a turned section", () => {
+			const plain = camTl({});
+			const { unmount } = render(<FloatingInspector {...defaultProps} tl={plain.tl} />);
+			expect(
+				screen.queryByRole("button", { name: "settings.cameraFullscreen.showLabel" }),
+			).toBeNull();
+			unmount();
+			const turned = camTl({ rotation: 180 });
+			render(<FloatingInspector {...defaultProps} tl={turned.tl} />);
+			const toggle = screen.getByRole("button", { name: "settings.cameraFullscreen.showLabel" });
+			expect(toggle).toHaveAttribute("aria-pressed", "true");
+			fireEvent.click(toggle);
+			expect(turned.updateCameraFullscreenDeskLabel).toHaveBeenCalledWith("cf", false);
+		});
+
+		it("changes the mirror without touching the rotation", () => {
+			const { tl, updateCameraFullscreenOrientation } = camTl({ rotation: 180 });
+			render(<FloatingInspector {...defaultProps} tl={tl} />);
+			fireEvent.click(screen.getByRole("button", { name: "settings.cameraFullscreen.mirror.on" }));
+			expect(updateCameraFullscreenOrientation).toHaveBeenCalledWith("cf", {
+				rotation: 180,
+				mirror: "on",
+			});
+		});
+	});
 });
 
 describe("AnnotationSizeField", () => {
diff --git a/src/components/ai-edition/v4/FloatingInspector.tsx b/src/components/ai-edition/v4/FloatingInspector.tsx
index 8b0bac86e..db594f517 100644
--- a/src/components/ai-edition/v4/FloatingInspector.tsx
+++ b/src/components/ai-edition/v4/FloatingInspector.tsx
@@ -17,6 +17,7 @@ import {
 	Maximize2,
 	MousePointer2,
 	Pencil,
+	RotateCw,
 	Scissors,
 	SlidersHorizontal,
 	Trash2,
@@ -60,6 +61,14 @@ import { useEditorSettings } from "@/lib/ai-edition/store/useEditorSettings";
 import type { useTimeline } from "@/lib/ai-edition/store/useTimeline";
 import { formatSeconds } from "@/lib/ai-edition/timeline/format";
 import { coalescedTrimGroups } from "@/lib/ai-edition/timeline/trim-mapping";
+import {
+	type CameraMirrorMode,
+	type CameraRotation,
+	isDeskView,
+	normalizeCameraMirror,
+	normalizeCameraRotation,
+	showsDeskLabel,
+} from "@/lib/cameraOrientation";
 import { clampToBound } from "@/lib/projectDefaults";
 import { annotationFootageRect, zoomScaleLimit } from "@/native/sceneDescription";
 import { ColorField } from "../ColorField";
@@ -71,6 +80,7 @@ import {
 	CursorPane,
 	LayoutPane,
 	SliderCell,
+	Toggle,
 	TranscriptPane,
 	VideoEffectsPane,
 } from "../RightPanes";
@@ -1267,6 +1277,11 @@ function SelectionPane({ tl, onClose }: { tl: TimelineApi; onClose: () => void }
 	if (selection.kind === "cameraFullscreen") {
 		const region = tl.cameraFullscreenRegions.find((c) => c.id === selection.id);
 		if (!region) return null;
+		const rotation = normalizeCameraRotation(region.rotation);
+		const mirror = normalizeCameraMirror(region.mirror);
+		const desk = isDeskView(region);
+		const setOrientation = (next: { rotation: CameraRotation; mirror: CameraMirrorMode }) =>
+			void tl.updateCameraFullscreenOrientation(region.id, next);
 		return (
 			<div style={{ display: "flex", flexDirection: "column", minHeight: 0 }}>
 				{paneHeader(
@@ -1276,6 +1291,55 @@ function SelectionPane({ tl, onClose }: { tl: TimelineApi; onClose: () => void }
 					tc("actions.close"),
 				)}
 				<div style={bodyStyle}>
+					{/* One click for the common case: a camera tilted onto the desk is upside down
+					    and must not be mirrored, or the papers' text reads back to front. */}
+					<button
+						type="button"
+						aria-pressed={desk}
+						onClick={() =>
+							setOrientation(
+								desk ? { rotation: 0, mirror: "auto" } : { rotation: 180, mirror: "auto" },
+							)
+						}
+						className={`${PANE_BUTTON} ${styles.paneToggle}`}
+					>
+						<RotateCw size={16} />
+						{ts("cameraFullscreen.deskView")}
+					</button>
+					{paneStack(
+						ts("cameraFullscreen.rotation"),
+						<ChoiceRow<CameraRotation>
+							label={ts("cameraFullscreen.rotation")}
+							options={[
+								{ value: 0, label: "0°" },
+								{ value: 180, label: "180°" },
+							]}
+							value={rotation}
+							onChange={(next) => setOrientation({ rotation: next, mirror })}
+						/>,
+					)}
+					{paneStack(
+						ts("cameraFullscreen.mirror.title"),
+						<ChoiceRow<CameraMirrorMode>
+							label={ts("cameraFullscreen.mirror.title")}
+							options={[
+								{ value: "auto", label: ts("cameraFullscreen.mirror.auto") },
+								{ value: "on", label: ts("cameraFullscreen.mirror.on") },
+								{ value: "off", label: ts("cameraFullscreen.mirror.off") },
+							]}
+							value={mirror}
+							onChange={(next) => setOrientation({ rotation, mirror: next })}
+						/>,
+					)}
+					{rotation === 180 &&
+						paneRow(
+							ts("cameraFullscreen.showLabel"),
+							<Toggle
+								checked={showsDeskLabel(region)}
+								ariaLabel={ts("cameraFullscreen.showLabel")}
+								onChange={(v) => void tl.updateCameraFullscreenDeskLabel(region.id, v)}
+							/>,
+						)}
 					<button type="button" onClick={deleteAndClose} className={PANE_BUTTON}>
 						<Trash2 size={16} style={{ color: "var(--danger)" }} />
 						{te("inspector.deleteRegion")}
diff --git a/src/components/ai-edition/v4/V4Timeline.tsx b/src/components/ai-edition/v4/V4Timeline.tsx
index a29b9c239..f50942b3d 100644
--- a/src/components/ai-edition/v4/V4Timeline.tsx
+++ b/src/components/ai-edition/v4/V4Timeline.tsx
@@ -9,6 +9,7 @@ import {
 	Mic,
 	Music,
 	Pencil,
+	RotateCw,
 	Scissors,
 	Sparkles,
 	Trash2,
@@ -67,6 +68,7 @@ import {
 	resolveTimelineSpanToTrim,
 	ventilateTimelineSpanToTrims,
 } from "@/lib/ai-edition/timeline/trim-mapping";
+import { normalizeCameraRotation } from "@/lib/cameraOrientation";
 import { formatBinding } from "@/lib/shortcuts";
 import { nativeBridgeClient } from "@/native/client";
 import { TransportBar } from "../TransportBar";
@@ -596,6 +598,8 @@ interface LanePill {
 	label: string;
 	/** Underlying row ids this pill represents — >1 for a coalesced trim group. */
 	sourceIds: string[];
+	/** Desk-view section: the camera is turned 180 degrees. */
+	rotated?: boolean;
 }
 
 export function V4Timeline({
@@ -758,6 +762,7 @@ export function V4Timeline({
 			end: p.end,
 			label: "Full Camera",
 			sourceIds: p.ids,
+			rotated: normalizeCameraRotation(p.member.rotation) === 180,
 		}),
 	);
 	const zoomPills: LanePill[] = coalesceRegionsForRuler(tl.zoomRegions).map((p) => ({
@@ -1417,7 +1422,7 @@ export function V4Timeline({
 					: kind === "cameraFullscreen"
 						? styles.laneCameraFullscreen
 						: styles.laneZoom;
-	const pillIcon = (kind: LanePill["kind"]) =>
+	const pillIcon = (kind: LanePill["kind"], rotated?: boolean) =>
 		kind === "annotation" ? (
 			<MessageSquare size={12} />
 		) : kind === "speed" ? (
@@ -1425,7 +1430,11 @@ export function V4Timeline({
 		) : kind === "trim" ? (
 			<Scissors size={12} />
 		) : kind === "cameraFullscreen" ? (
-			<Maximize2 size={12} />
+			rotated ? (
+				<RotateCw size={12} />
+			) : (
+				<Maximize2 size={12} />
+			)
 		) : (
 			<ZoomIn size={12} />
 		);
@@ -1712,7 +1721,7 @@ export function V4Timeline({
 				) : null}
 				{seg.showContent && roomForLabel ? (
 					<>
-						{pillIcon(p.kind)}
+						{pillIcon(p.kind, p.rotated)}
 						<span className={styles.lanePillLabel}>{p.label}</span>
 					</>
 				) : null}
diff --git a/src/components/video-editor/projectPersistence.test.ts b/src/components/video-editor/projectPersistence.test.ts
index ed146c59a..f65c845e2 100644
--- a/src/components/video-editor/projectPersistence.test.ts
+++ b/src/components/video-editor/projectPersistence.test.ts
@@ -77,6 +77,36 @@ describe("projectPersistence media compatibility", () => {
 
 	// The CLI export reads projects through this function: a dropped key is a motion the
 	// preview shows and the export does not.
+	it("keeps a Full Camera section's orientation and drops unknown values", () => {
+		const editor = normalizeProjectEditor({
+			cameraFullscreenRegions: [
+				{ id: "a", startMs: 0, endMs: 1000, rotation: 180, mirror: "off" },
+				{ id: "b", startMs: 2000, endMs: 3000, rotation: 90 as never, mirror: "sideways" as never },
+				{ id: "c", startMs: 4000, endMs: 5000 },
+			],
+		});
+		expect(editor.cameraFullscreenRegions).toEqual([
+			{ id: "a", startMs: 0, endMs: 1000, rotation: 180, mirror: "off" },
+			{ id: "b", startMs: 2000, endMs: 3000 },
+			{ id: "c", startMs: 4000, endMs: 5000 },
+		]);
+	});
+
+	it("keeps the desk label switch only as false", () => {
+		const editor = normalizeProjectEditor({
+			cameraFullscreenRegions: [
+				{ id: "d", startMs: 6000, endMs: 7000, rotation: 180, deskLabel: false },
+				{ id: "e", startMs: 8000, endMs: 9000, deskLabel: true as never },
+				{ id: "f", startMs: 10000, endMs: 11000, deskLabel: "x" as never },
+			],
+		});
+		expect(editor.cameraFullscreenRegions).toEqual([
+			{ id: "d", startMs: 6000, endMs: 7000, rotation: 180, deskLabel: false },
+			{ id: "e", startMs: 8000, endMs: 9000 },
+			{ id: "f", startMs: 10000, endMs: 11000 },
+		]);
+	});
+
 	it("keeps a known wallpaper motion and drops an unknown one", () => {
 		expect(normalizeProjectEditor({ wallpaperMotion: "drift" }).wallpaperMotion).toBe("drift");
 		expect(normalizeProjectEditor({}).wallpaperMotion).toBe("none");
diff --git a/src/components/video-editor/projectPersistence.ts b/src/components/video-editor/projectPersistence.ts
index a533be7ab..f855ca6b8 100644
--- a/src/components/video-editor/projectPersistence.ts
+++ b/src/components/video-editor/projectPersistence.ts
@@ -1,5 +1,6 @@
 import { normalizeTextAnimation } from "@/lib/annotationTextAnimation";
 import { normalizeBlurColor, normalizeBlurType } from "@/lib/blurEffects";
+import { normalizeCameraMirror, normalizeCameraRotation } from "@/lib/cameraOrientation";
 import {
 	type CursorKind,
 	normalizeCursorThemeId,
@@ -318,10 +319,15 @@ export function normalizeProjectEditor(editor: Partial<ProjectEditorState>): Pro
 					const rawEnd = isFiniteNumber(region.endMs) ? Math.round(region.endMs) : rawStart + 1000;
 					const startMs = Math.max(0, Math.min(rawStart, rawEnd));
 					const endMs = Math.max(startMs + 1, rawEnd);
+					const rotation = normalizeCameraRotation(region.rotation);
+					const mirror = normalizeCameraMirror(region.mirror);
 					return {
 						id: region.id,
 						startMs,
 						endMs,
+						...(rotation !== 0 ? { rotation } : {}),
+						...(mirror !== "auto" ? { mirror } : {}),
+						...(region.deskLabel === false ? { deskLabel: false as const } : {}),
 					};
 				})
 		: [];
diff --git a/src/components/video-editor/types.ts b/src/components/video-editor/types.ts
index 0295f2366..a8bf36b4b 100644
--- a/src/components/video-editor/types.ts
+++ b/src/components/video-editor/types.ts
@@ -3,6 +3,7 @@ import {
 	type ZoomDepth,
 	type ZoomScaleInput,
 } from "@/lib/ai-edition/timeline/zoom-scale";
+import type { CameraMirrorMode, CameraRotation } from "@/lib/cameraOrientation";
 import type { WebcamLayoutPreset } from "@/lib/compositeLayout";
 import type { CursorKind } from "@/lib/cursor/cursorThemes";
 import { DEFAULT_PROJECT_APPEARANCE, SETTING_BOUNDS } from "@/lib/projectDefaults";
@@ -320,12 +321,18 @@ export interface TrimRegion {
  * animates its size/position until it covers the entire canvas, visually hiding the
  * desktop behind it (the desktop keeps recording underneath, it's just covered).
  * No focus/depth/rotation needed: unlike ZoomRegion, the destination is always "fill the
- * canvas", so the shape stays intentionally simpler.
+ * canvas", so the shape stays intentionally simpler. Can be rotated 180° for desk shots.
  */
 export interface CameraFullscreenRegion {
 	id: string;
 	startMs: number;
 	endMs: number;
+	/** 180 turns the camera for a desk shot. Absent = 0. Read through `normalizeCameraRotation`. */
+	rotation?: CameraRotation;
+	/** Absent = "auto": the project's mirror, off while turned. Read through `normalizeCameraMirror`. */
+	mirror?: CameraMirrorMode;
+	/** Stored only as `false`: hides the "Desk mode" label of a turned section. Read through `showsDeskLabel`. */
+	deskLabel?: false;
 }
 
 export type AnnotationType = "text" | "image" | "figure" | "blur";
diff --git a/src/i18n/locales/ar/settings.json b/src/i18n/locales/ar/settings.json
index 78854c26c..458821341 100644
--- a/src/i18n/locales/ar/settings.json
+++ b/src/i18n/locales/ar/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "اقتصاص الفيديو",
 		"lockAspectRatio": "قفل نسبة العرض إلى الارتفاع"
 	},
+	"cameraFullscreen": {
+		"deskView": "عرض المكتب",
+		"deskLabel": "وضع المكتب",
+		"showLabel": "إظهار التسمية",
+		"rotation": "تدوير",
+		"mirror": {
+			"title": "انعكاس",
+			"auto": "تلقائي",
+			"on": "تشغيل",
+			"off": "إيقاف"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/cs/settings.json b/src/i18n/locales/cs/settings.json
index c0f0c73eb..c84efbd18 100644
--- a/src/i18n/locales/cs/settings.json
+++ b/src/i18n/locales/cs/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "Oříznout video",
 		"lockAspectRatio": "Zamknout poměr stran"
 	},
+	"cameraFullscreen": {
+		"deskView": "Pohled na stůl",
+		"deskLabel": "Režim stolu",
+		"showLabel": "Zobrazit popisek",
+		"rotation": "Otočení",
+		"mirror": {
+			"title": "Zrcadlit",
+			"auto": "Auto",
+			"on": "Zap.",
+			"off": "Vyp."
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/de/settings.json b/src/i18n/locales/de/settings.json
index 3e6af58b1..36f57f709 100644
--- a/src/i18n/locales/de/settings.json
+++ b/src/i18n/locales/de/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "Video zuschneiden",
 		"lockAspectRatio": "Seitenverhältnis sperren"
 	},
+	"cameraFullscreen": {
+		"deskView": "Schreibtisch-Ansicht",
+		"deskLabel": "Schreibtischmodus",
+		"showLabel": "Schriftzug zeigen",
+		"rotation": "Drehung",
+		"mirror": {
+			"title": "Spiegeln",
+			"auto": "Auto",
+			"on": "An",
+			"off": "Aus"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/en/settings.json b/src/i18n/locales/en/settings.json
index 867827cc1..813ce382e 100644
--- a/src/i18n/locales/en/settings.json
+++ b/src/i18n/locales/en/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "Crop Video",
 		"lockAspectRatio": "Lock aspect ratio"
 	},
+	"cameraFullscreen": {
+		"deskView": "Desk view",
+		"deskLabel": "Desk mode",
+		"showLabel": "Show label",
+		"rotation": "Rotation",
+		"mirror": {
+			"title": "Mirror",
+			"auto": "Auto",
+			"on": "On",
+			"off": "Off"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/es/settings.json b/src/i18n/locales/es/settings.json
index 7d906c4e0..946ec2b38 100644
--- a/src/i18n/locales/es/settings.json
+++ b/src/i18n/locales/es/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "Recortar video",
 		"lockAspectRatio": "Bloquear relación de aspecto"
 	},
+	"cameraFullscreen": {
+		"deskView": "Vista de escritorio",
+		"deskLabel": "Modo escritorio",
+		"showLabel": "Mostrar rótulo",
+		"rotation": "Rotación",
+		"mirror": {
+			"title": "Espejo",
+			"auto": "Auto",
+			"on": "Sí",
+			"off": "No"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/fr/settings.json b/src/i18n/locales/fr/settings.json
index 7561410e2..dbcc91c15 100644
--- a/src/i18n/locales/fr/settings.json
+++ b/src/i18n/locales/fr/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "Recadrer la vidéo",
 		"lockAspectRatio": "Verrouiller le ratio"
 	},
+	"cameraFullscreen": {
+		"deskView": "Vue bureau",
+		"deskLabel": "Mode bureau",
+		"showLabel": "Afficher le titre",
+		"rotation": "Rotation",
+		"mirror": {
+			"title": "Miroir",
+			"auto": "Auto",
+			"on": "Activé",
+			"off": "Désactivé"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/it/settings.json b/src/i18n/locales/it/settings.json
index 555c0dbb3..873fbf75d 100644
--- a/src/i18n/locales/it/settings.json
+++ b/src/i18n/locales/it/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "Ritaglia video",
 		"lockAspectRatio": "Blocca proporzioni"
 	},
+	"cameraFullscreen": {
+		"deskView": "Vista scrivania",
+		"deskLabel": "Modalità scrivania",
+		"showLabel": "Mostra etichetta",
+		"rotation": "Rotazione",
+		"mirror": {
+			"title": "Specchio",
+			"auto": "Auto",
+			"on": "Sì",
+			"off": "No"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/ja-JP/settings.json b/src/i18n/locales/ja-JP/settings.json
index dba5bf24f..91c65bd9f 100644
--- a/src/i18n/locales/ja-JP/settings.json
+++ b/src/i18n/locales/ja-JP/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "動画をクロップ",
 		"lockAspectRatio": "アスペクト比を固定"
 	},
+	"cameraFullscreen": {
+		"deskView": "机上ビュー",
+		"deskLabel": "机上モード",
+		"showLabel": "ラベルを表示",
+		"rotation": "回転",
+		"mirror": {
+			"title": "ミラー",
+			"auto": "自動",
+			"on": "オン",
+			"off": "オフ"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/ko-KR/settings.json b/src/i18n/locales/ko-KR/settings.json
index cc6882854..9e25cb89c 100644
--- a/src/i18n/locales/ko-KR/settings.json
+++ b/src/i18n/locales/ko-KR/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "비디오 자르기",
 		"lockAspectRatio": "화면 비율 고정"
 	},
+	"cameraFullscreen": {
+		"deskView": "책상 보기",
+		"deskLabel": "책상 모드",
+		"showLabel": "라벨 표시",
+		"rotation": "회전",
+		"mirror": {
+			"title": "미러",
+			"auto": "자동",
+			"on": "켜기",
+			"off": "끄기"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/pt-BR/settings.json b/src/i18n/locales/pt-BR/settings.json
index 56bde8ca9..87480ebd8 100644
--- a/src/i18n/locales/pt-BR/settings.json
+++ b/src/i18n/locales/pt-BR/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "Cortar Vídeo",
 		"lockAspectRatio": "Bloquear proporção"
 	},
+	"cameraFullscreen": {
+		"deskView": "Visão da mesa",
+		"deskLabel": "Modo mesa",
+		"showLabel": "Mostrar rótulo",
+		"rotation": "Rotação",
+		"mirror": {
+			"title": "Espelhar",
+			"auto": "Auto",
+			"on": "Ligado",
+			"off": "Desligado"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/ru/settings.json b/src/i18n/locales/ru/settings.json
index f16d8fc16..6935b8570 100644
--- a/src/i18n/locales/ru/settings.json
+++ b/src/i18n/locales/ru/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "Обрезать видео",
 		"lockAspectRatio": "Заблокировать соотношение сторон"
 	},
+	"cameraFullscreen": {
+		"deskView": "Вид на стол",
+		"deskLabel": "Режим стола",
+		"showLabel": "Показывать надпись",
+		"rotation": "Поворот",
+		"mirror": {
+			"title": "Зеркало",
+			"auto": "Авто",
+			"on": "Вкл.",
+			"off": "Выкл."
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/tr/settings.json b/src/i18n/locales/tr/settings.json
index 1f500503e..8d6810bb2 100644
--- a/src/i18n/locales/tr/settings.json
+++ b/src/i18n/locales/tr/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "Videoyu Kırp",
 		"lockAspectRatio": "En boy oranını kilitle"
 	},
+	"cameraFullscreen": {
+		"deskView": "Masa görünümü",
+		"deskLabel": "Masa modu",
+		"showLabel": "Etiketi göster",
+		"rotation": "Döndürme",
+		"mirror": {
+			"title": "Ayna",
+			"auto": "Otomatik",
+			"on": "Açık",
+			"off": "Kapalı"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/vi/settings.json b/src/i18n/locales/vi/settings.json
index ce6f50f7c..426a820da 100644
--- a/src/i18n/locales/vi/settings.json
+++ b/src/i18n/locales/vi/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "Cắt xén video",
 		"lockAspectRatio": "Khóa tỷ lệ khung hình"
 	},
+	"cameraFullscreen": {
+		"deskView": "Góc nhìn bàn làm việc",
+		"deskLabel": "Chế độ bàn",
+		"showLabel": "Hiện nhãn",
+		"rotation": "Xoay",
+		"mirror": {
+			"title": "Phản chiếu",
+			"auto": "Tự động",
+			"on": "Bật",
+			"off": "Tắt"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/zh-CN/settings.json b/src/i18n/locales/zh-CN/settings.json
index bfe73d781..77472879b 100644
--- a/src/i18n/locales/zh-CN/settings.json
+++ b/src/i18n/locales/zh-CN/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "裁剪视频",
 		"lockAspectRatio": "锁定宽高比"
 	},
+	"cameraFullscreen": {
+		"deskView": "书桌视图",
+		"deskLabel": "书桌模式",
+		"showLabel": "显示标签",
+		"rotation": "旋转",
+		"mirror": {
+			"title": "镜像",
+			"auto": "自动",
+			"on": "开",
+			"off": "关"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/i18n/locales/zh-TW/settings.json b/src/i18n/locales/zh-TW/settings.json
index 481582a13..e47ff0583 100644
--- a/src/i18n/locales/zh-TW/settings.json
+++ b/src/i18n/locales/zh-TW/settings.json
@@ -353,6 +353,18 @@
 		"cropVideo": "裁剪影片",
 		"lockAspectRatio": "鎖定長寬比"
 	},
+	"cameraFullscreen": {
+		"deskView": "書桌檢視",
+		"deskLabel": "書桌模式",
+		"showLabel": "顯示標籤",
+		"rotation": "旋轉",
+		"mirror": {
+			"title": "鏡像",
+			"auto": "自動",
+			"on": "開",
+			"off": "關"
+		}
+	},
 	"zoom": {
 		"position": {
 			"y": "Y (%)",
diff --git a/src/lib/ai-edition/store/documentWriteAudit.test.ts b/src/lib/ai-edition/store/documentWriteAudit.test.ts
index 82268bc82..fcf02236e 100644
--- a/src/lib/ai-edition/store/documentWriteAudit.test.ts
+++ b/src/lib/ai-edition/store/documentWriteAudit.test.ts
@@ -292,6 +292,18 @@ const DECLARED: WritePath[] = [
 	// The live halves of the two drags.
 	w("src/lib/ai-edition/store/useTimeline.ts", "updateAnnotationLive", "set", "automatic"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "updateAnnotationSpan", "save", "gesture"),
+	w(
+		"src/lib/ai-edition/store/useTimeline.ts",
+		"updateCameraFullscreenOrientation",
+		"save",
+		"gesture",
+	),
+	w(
+		"src/lib/ai-edition/store/useTimeline.ts",
+		"updateCameraFullscreenDeskLabel",
+		"save",
+		"gesture",
+	),
 	w("src/lib/ai-edition/store/useTimeline.ts", "updateCameraFullscreenSpan", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "updateSpeedSpan", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "updateSpeedValue", "save", "gesture"),
diff --git a/src/lib/ai-edition/store/useTimeline.test.ts b/src/lib/ai-edition/store/useTimeline.test.ts
index bb99bcb1c..2b2ae4830 100644
--- a/src/lib/ai-edition/store/useTimeline.test.ts
+++ b/src/lib/ai-edition/store/useTimeline.test.ts
@@ -2561,3 +2561,110 @@ describe("useTimeline.addZoomsBulk reads the document at write time", () => {
 		expect(bridgeMocks.save).not.toHaveBeenCalled();
 	});
 });
+
+describe("useTimeline.updateCameraFullscreenOrientation", () => {
+	type Cam = {
+		id: string;
+		startMs: number;
+		endMs: number;
+		rotation?: 180;
+		mirror?: string;
+		deskLabel?: false;
+	};
+	const stored = () =>
+		(
+			(useProjectStore.getState().document?.legacyEditor ?? {}) as {
+				cameraFullscreenRegions?: Cam[];
+			}
+		).cameraFullscreenRegions;
+
+	function seedRegions(cameraFullscreenRegions: Cam[]) {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: { ...sampleDoc, legacyEditor: { cameraFullscreenRegions } },
+			currentTimeSec: 1,
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+	}
+
+	beforeEach(() => {
+		useProjectStore.getState().clear();
+		clearHistory();
+		for (const mock of Object.values(bridgeMocks)) mock.mockReset();
+		bridgeMocks.save.mockImplementation(async (doc: typeof sampleDoc) => ({
+			success: true,
+			document: doc,
+		}));
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("desk view sets both fields in one history step", async () => {
+		seedRegions([{ id: "cf", startMs: 0, endMs: 2000 }]);
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.updateCameraFullscreenOrientation("cf", {
+				rotation: 180,
+				mirror: "auto",
+			});
+		});
+		expect(stored()).toEqual([{ id: "cf", startMs: 0, endMs: 2000, rotation: 180 }]);
+		act(() => {
+			expect(undo()).toBe(true);
+		});
+		expect(stored()).toEqual([{ id: "cf", startMs: 0, endMs: 2000 }]);
+	});
+
+	it("clears the fields instead of writing defaults", async () => {
+		seedRegions([{ id: "cf", startMs: 0, endMs: 2000, rotation: 180, mirror: "on" }]);
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.updateCameraFullscreenOrientation("cf", {
+				rotation: 0,
+				mirror: "auto",
+			});
+		});
+		expect(stored()).toEqual([{ id: "cf", startMs: 0, endMs: 2000 }]);
+	});
+
+	it("stores only false for the desk label, in one history step", async () => {
+		seedRegions([{ id: "cf", startMs: 0, endMs: 2000, rotation: 180 }]);
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.updateCameraFullscreenDeskLabel("cf", false);
+		});
+		expect(stored()).toEqual([
+			{ id: "cf", startMs: 0, endMs: 2000, rotation: 180, deskLabel: false },
+		]);
+		await act(async () => {
+			await result.current.updateCameraFullscreenDeskLabel("cf", true);
+		});
+		expect(stored()).toEqual([{ id: "cf", startMs: 0, endMs: 2000, rotation: 180 }]);
+		act(() => {
+			expect(undo()).toBe(true);
+		});
+		expect(stored()?.[0].deskLabel).toBe(false);
+	});
+
+	it("patches every row of a ventilated pill", async () => {
+		// Two abutting rows with equal properties read as one pill (`resolvePillIds`); a change
+		// to one row only would make them differ and split the pill in two.
+		seedRegions([
+			{ id: "a", startMs: 0, endMs: 1000 },
+			{ id: "b", startMs: 1000, endMs: 2000 },
+			{ id: "other", startMs: 5000, endMs: 6000 },
+		]);
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.updateCameraFullscreenOrientation("a", {
+				rotation: 180,
+				mirror: "auto",
+			});
+		});
+		expect(stored()?.map((r) => r.rotation)).toEqual([180, 180, undefined]);
+	});
+});
diff --git a/src/lib/ai-edition/store/useTimeline.ts b/src/lib/ai-edition/store/useTimeline.ts
index 2b5eb6be4..e94d23203 100644
--- a/src/lib/ai-edition/store/useTimeline.ts
+++ b/src/lib/ai-edition/store/useTimeline.ts
@@ -9,9 +9,16 @@ import { toFileUrl } from "@/components/video-editor/projectPersistence";
 import type {
 	AnnotationRegion,
 	AnnotationType,
+	CameraFullscreenRegion,
 	Rotation3DPreset,
 } from "@/components/video-editor/types";
 import { useScopedT } from "@/contexts/I18nContext";
+import {
+	type CameraMirrorMode,
+	type CameraRotation,
+	normalizeCameraMirror,
+	normalizeCameraRotation,
+} from "@/lib/cameraOrientation";
 import { DEFAULT_TEXT_PLATE } from "../annotations/background";
 import { fitTextBox } from "../annotations/placement";
 import {
@@ -1074,6 +1081,56 @@ export function useTimeline() {
 		[document, saveDocument],
 	);
 
+	const updateCameraFullscreenOrientation = useCallback(
+		async (id: string, orientation: { rotation: CameraRotation; mirror: CameraMirrorMode }) => {
+			if (!document) return;
+			const legacy = (document.legacyEditor as Record<string, unknown>) ?? {};
+			const prev = ((legacy.cameraFullscreenRegions as unknown[]) ??
+				[]) as CameraFullscreenRegion[];
+			const rotation = normalizeCameraRotation(orientation.rotation);
+			const mirror = normalizeCameraMirror(orientation.mirror);
+			// Defaults are not stored: a section turned back to plain is byte-identical to one
+			// that was never touched.
+			// patchPillById copies exactly the pill's rows; untouched rows keep their identity.
+			const patched = patchPillById(prev, id, {}).map((r, i) => {
+				if (r === prev[i]) return r;
+				const { rotation: _r, mirror: _m, ...rest } = r;
+				return {
+					...rest,
+					...(rotation !== 0 ? { rotation } : {}),
+					...(mirror !== "auto" ? { mirror } : {}),
+				};
+			});
+			const next: AxcutDocument = {
+				...document,
+				legacyEditor: { ...legacy, cameraFullscreenRegions: patched },
+			};
+			await saveDocument(next, { history: true });
+		},
+		[document, saveDocument],
+	);
+
+	const updateCameraFullscreenDeskLabel = useCallback(
+		async (id: string, show: boolean) => {
+			if (!document) return;
+			const legacy = (document.legacyEditor as Record<string, unknown>) ?? {};
+			const prev = ((legacy.cameraFullscreenRegions as unknown[]) ??
+				[]) as CameraFullscreenRegion[];
+			// patchPillById copies exactly the pill's rows; untouched rows keep their identity.
+			const patched = patchPillById(prev, id, {}).map((r, i) => {
+				if (r === prev[i]) return r;
+				const { deskLabel: _d, ...rest } = r;
+				return show ? rest : { ...rest, deskLabel: false as const };
+			});
+			const next: AxcutDocument = {
+				...document,
+				legacyEditor: { ...legacy, cameraFullscreenRegions: patched },
+			};
+			await saveDocument(next, { history: true });
+		},
+		[document, saveDocument],
+	);
+
 	const removeRegion = useCallback(
 		async (kind: RegionKind, id: string) => {
 			if (!document) return;
@@ -1442,11 +1499,7 @@ export function useTimeline() {
 
 	const cameraFullscreenRegions = hasDoc
 		? (((document.legacyEditor as Record<string, unknown> | null)
-				?.cameraFullscreenRegions as Array<{
-				id: string;
-				startMs: number;
-				endMs: number;
-			}>) ?? [])
+				?.cameraFullscreenRegions as CameraFullscreenRegion[]) ?? [])
 		: [];
 
 	// --- Timeline audio tracks (issue #350) -------------------------------------
@@ -1686,6 +1739,8 @@ export function useTimeline() {
 		commitAnnotationChange,
 		updateSpeedSpan,
 		updateSpeedValue,
+		updateCameraFullscreenOrientation,
+		updateCameraFullscreenDeskLabel,
 		updateCameraFullscreenSpan,
 		// T19 — drives the preview video during trim-edge resize.
 		setCurrentTime: useProjectStore((s) => s.setCurrentTime),
diff --git a/src/lib/ai-edition/timeline/timelineMap.test.ts b/src/lib/ai-edition/timeline/timelineMap.test.ts
index ea3f6c61b..70f46158f 100644
--- a/src/lib/ai-edition/timeline/timelineMap.test.ts
+++ b/src/lib/ai-edition/timeline/timelineMap.test.ts
@@ -745,6 +745,18 @@ describe("pills wired to the universal rules", () => {
 		expect(coalesceRegionsForRuler(out)).toHaveLength(1);
 	});
 
+	it("keeps orientation when the span is replaced", () => {
+		const regions = anchorRegionsWithDerivedMs(
+			[{ id: "cf", startMs: 2000, endMs: 5000, rotation: 180 as const }],
+			clips,
+			ids(),
+		);
+		// Resized across the clip boundary: re-anchored into one fragment per clip.
+		const out = replacePillSpan(regions, "cf", 20000, 28000, clips, ids());
+		expect(out).toHaveLength(2);
+		expect(out.every((r) => r.rotation === 180)).toBe(true);
+	});
+
 	it("clamps a resize at a neighbouring pill of different properties (magnet)", () => {
 		const regions = [
 			...anchorRegionsWithDerivedMs(
diff --git a/src/lib/cameraOrientation.test.ts b/src/lib/cameraOrientation.test.ts
new file mode 100644
index 000000000..20f11cd4e
--- /dev/null
+++ b/src/lib/cameraOrientation.test.ts
@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import {
+	isDeskView,
+	normalizeCameraMirror,
+	normalizeCameraRotation,
+	resolveCameraOrientation,
+	showsDeskLabel,
+} from "./cameraOrientation";
+
+describe("normalizeCameraRotation", () => {
+	it("keeps 0 and 180", () => {
+		expect(normalizeCameraRotation(0)).toBe(0);
+		expect(normalizeCameraRotation(180)).toBe(180);
+	});
+	it("reads anything else as 0, so a newer project opens unrotated", () => {
+		for (const v of [90, 270, -180, "180", null, undefined, Number.NaN]) {
+			expect(normalizeCameraRotation(v)).toBe(0);
+		}
+	});
+});
+
+describe("normalizeCameraMirror", () => {
+	it("keeps the three modes and reads anything else as auto", () => {
+		expect(normalizeCameraMirror("on")).toBe("on");
+		expect(normalizeCameraMirror("off")).toBe("off");
+		expect(normalizeCameraMirror("auto")).toBe("auto");
+		expect(normalizeCameraMirror(true)).toBe("auto");
+		expect(normalizeCameraMirror(undefined)).toBe("auto");
+	});
+});
+
+describe("resolveCameraOrientation", () => {
+	it("is the project's mirror and no rotation outside a section", () => {
+		expect(resolveCameraOrientation(null, true)).toEqual({
+			rotation: 0,
+			mirror: true,
+			fullFrame: false,
+		});
+	});
+	it("leaves a plain Full Camera section as the project has it", () => {
+		expect(resolveCameraOrientation({}, true)).toEqual({
+			rotation: 0,
+			mirror: true,
+			fullFrame: false,
+		});
+	});
+	it("resolves auto to off when turned, even with the project mirror on", () => {
+		expect(resolveCameraOrientation({ rotation: 180 }, true)).toEqual({
+			rotation: 180,
+			mirror: false,
+			fullFrame: true,
+		});
+	});
+	it("honours an explicit mirror on a turned section", () => {
+		expect(resolveCameraOrientation({ rotation: 180, mirror: "on" }, false).mirror).toBe(true);
+		expect(resolveCameraOrientation({ rotation: 0, mirror: "off" }, true).mirror).toBe(false);
+	});
+	it("treats an unknown rotation as none", () => {
+		expect(resolveCameraOrientation({ rotation: 90 }, false)).toEqual({
+			rotation: 0,
+			mirror: false,
+			fullFrame: false,
+		});
+	});
+});
+
+describe("isDeskView", () => {
+	it("is rotation 180 with mirror auto", () => {
+		expect(isDeskView({ rotation: 180 })).toBe(true);
+		expect(isDeskView({ rotation: 180, mirror: "auto" })).toBe(true);
+		expect(isDeskView({ rotation: 180, mirror: "on" })).toBe(false);
+		expect(isDeskView({})).toBe(false);
+	});
+});
+
+describe("showsDeskLabel", () => {
+	it("shows unless explicitly false", () => {
+		expect(showsDeskLabel({})).toBe(true);
+		expect(showsDeskLabel({ deskLabel: false })).toBe(false);
+		expect(showsDeskLabel({ deskLabel: "no" })).toBe(true);
+	});
+});
diff --git a/src/lib/cameraOrientation.ts b/src/lib/cameraOrientation.ts
new file mode 100644
index 000000000..11ec777fd
--- /dev/null
+++ b/src/lib/cameraOrientation.ts
@@ -0,0 +1,52 @@
+/**
+ * How the webcam is laid onto the frame inside a Full Camera section.
+ *
+ * A camera tilted down onto a desk sees the papers upside down, so a section can turn
+ * the picture 180°. Mirroring follows the project unless the section says otherwise,
+ * except that a turned section un-mirrors by default: the selfie mirror that suits a
+ * face would print the papers' text back to front.
+ *
+ * The stored fields are read through here everywhere (scene, inspector, DOM preview),
+ * so a value this build does not know — a 90° from a later version — reads as "none"
+ * instead of reaching the compositor.
+ */
+export type CameraRotation = 0 | 180;
+export type CameraMirrorMode = "auto" | "on" | "off";
+
+export interface ResolvedCameraOrientation {
+	rotation: CameraRotation;
+	mirror: boolean;
+	/** Show the whole camera frame; the face crop/zoom does not apply. */
+	fullFrame: boolean;
+}
+
+export function normalizeCameraRotation(value: unknown): CameraRotation {
+	return value === 180 ? 180 : 0;
+}
+
+export function normalizeCameraMirror(value: unknown): CameraMirrorMode {
+	return value === "on" || value === "off" ? value : "auto";
+}
+
+export function resolveCameraOrientation(
+	region: { rotation?: unknown; mirror?: unknown } | null | undefined,
+	projectMirror: boolean,
+): ResolvedCameraOrientation {
+	if (!region) return { rotation: 0, mirror: projectMirror, fullFrame: false };
+	const rotation = normalizeCameraRotation(region.rotation);
+	const mode = normalizeCameraMirror(region.mirror);
+	const mirror = mode === "on" ? true : mode === "off" ? false : rotation === 0 && projectMirror;
+	return { rotation, mirror, fullFrame: rotation !== 0 };
+}
+
+export function isDeskView(region: { rotation?: unknown; mirror?: unknown }): boolean {
+	return (
+		normalizeCameraRotation(region.rotation) === 180 &&
+		normalizeCameraMirror(region.mirror) === "auto"
+	);
+}
+
+/** The desk-mode label is on unless the section explicitly switched it off. */
+export function showsDeskLabel(region: { deskLabel?: unknown }): boolean {
+	return region.deskLabel !== false;
+}
diff --git a/src/lib/deskCover.ts b/src/lib/deskCover.ts
new file mode 100644
index 000000000..7b1430104
--- /dev/null
+++ b/src/lib/deskCover.ts
@@ -0,0 +1,9 @@
+/** Above captions (`CAPTION_Z_INDEX_BASE` = 100_000), so the label sits on top. */
+export const DESK_LABEL_Z_INDEX = 200_000;
+/**
+ * The desk-view label's text animation. It has no timing of its own: the compositor draws the
+ * label at the camera cover's strength (`annotation_text_state` in
+ * crates/compositor/src/text_anim.rs), so the label spans its whole section and the cover alone
+ * decides when it shows — on the screen clock, like the cover.
+ */
+export const DESK_COVER_ANIMATION = "deskCover";
diff --git a/src/native/sceneDescription.test.ts b/src/native/sceneDescription.test.ts
index 04a2aeeaa..365c1c995 100644
--- a/src/native/sceneDescription.test.ts
+++ b/src/native/sceneDescription.test.ts
@@ -5,12 +5,13 @@
 // and verify every derivation branch listed in the spec (background / clips / zoomRegions /
 // crop / settings mapping / output dims).
 
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import {
 	DEFAULT_CROP_REGION,
 	getZoomScale,
 	ZOOM_DEPTH_SCALES,
 } from "@/components/video-editor/types";
+import { toastText } from "@/i18n/toastText";
 import type {
 	AxcutAsset,
 	AxcutClip,
@@ -19,6 +20,7 @@ import type {
 } from "@/lib/ai-edition/schema";
 import { axcutSchemaVersion } from "@/lib/ai-edition/schema";
 import { CURSOR_KIND_IDS, DEFAULT_CURSOR_THEME_ID } from "@/lib/cursor/cursorThemes";
+import { DESK_COVER_ANIMATION } from "@/lib/deskCover";
 import { DEVICE_FRAMES } from "@/lib/projectDefaults";
 import { getFocusBoundsForScale } from "@/lib/zoomMath/focusUtils";
 import {
@@ -105,6 +107,12 @@ function makeDoc(
 
 // --- background ------------------------------------------------------------
 
+// Wraps the real translator so a single test can make it answer like a missing key.
+vi.mock("@/i18n/toastText", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@/i18n/toastText")>();
+	return { toastText: vi.fn(actual.toastText) };
+});
+
 describe("buildSceneDescription.background", () => {
 	it('"#123456" → color', () => {
 		const doc = makeDoc({ legacyEditor: { wallpaper: "#123456" } });
@@ -914,6 +922,36 @@ describe("buildSceneDescription.cameraFullscreenRegions", () => {
 		expect(cameraFullscreenRegions).toEqual([{ startSec: 2, endSec: 5.5 }]);
 	});
 
+	it("adds the translated desk label over a turned section, spanning all of it", () => {
+		const doc = makeDoc({
+			legacyEditor: {
+				cameraFullscreenRegions: [{ id: "cf1", startMs: 0, endMs: 20_000, rotation: 180 }],
+			},
+		});
+		const labels = buildSceneDescription(doc).annotations.filter(
+			(a) => a.text?.animation === DESK_COVER_ANIMATION,
+		);
+		expect(labels.map((a) => a.text?.content)).toEqual(["Desk mode"]);
+		expect(labels.every((a) => a.space === "frame")).toBe(true);
+		// The compositor draws it at the cover's strength, so it must be on screen wherever the
+		// cover can be: the whole section, whatever its length or speed.
+		expect(labels.map((a) => [a.startSec, a.endSec])).toEqual([[0, 20]]);
+	});
+
+	it("no label for a plain section or with the label off", () => {
+		for (const region of [
+			{ id: "cf1", startMs: 0, endMs: 20_000 },
+			{ id: "cf1", startMs: 0, endMs: 20_000, rotation: 180, deskLabel: false },
+		]) {
+			const doc = makeDoc({ legacyEditor: { cameraFullscreenRegions: [region] } });
+			expect(
+				buildSceneDescription(doc).annotations.some(
+					(a) => a.text?.animation === DESK_COVER_ANIMATION,
+				),
+			).toBe(false);
+		}
+	});
+
 	it("yields [] when legacyEditor.cameraFullscreenRegions is missing", () => {
 		const doc = makeDoc({ legacyEditor: {} });
 		expect(buildSceneDescription(doc).cameraFullscreenRegions).toEqual([]);
@@ -952,6 +990,62 @@ describe("buildSceneDescription.cameraFullscreenRegions", () => {
 		]);
 	});
 
+	it("labels each projected piece of a turned section, like the cover", () => {
+		const asset = makeAsset({ id: "a", originalPath: "/a.mp4" });
+		const clip1 = makeClip({
+			id: "c1",
+			assetId: "a",
+			sourceStartSec: 100,
+			sourceEndSec: 105,
+			timelineStartSec: 0,
+			timelineEndSec: 5,
+		});
+		const clip2 = makeClip({
+			id: "c2",
+			assetId: "a",
+			sourceStartSec: 200,
+			sourceEndSec: 205,
+			timelineStartSec: 5,
+			timelineEndSec: 10,
+		});
+		const doc = makeDoc({
+			assets: [asset],
+			clips: [clip1, clip2],
+			legacyEditor: {
+				cameraFullscreenRegions: [{ id: "cf1", startMs: 3000, endMs: 7000, rotation: 180 }],
+			},
+		});
+		const scene = buildSceneDescription(doc);
+		const labels = scene.annotations.filter((a) => a.text?.animation === DESK_COVER_ANIMATION);
+		expect(labels).toHaveLength(2);
+		expect(new Set(labels.map((a) => a.id)).size).toBe(2);
+		// Built from the section's own id, so a rebuild reuses them: the native text cache is
+		// keyed by id and never pruned.
+		const rebuilt = buildSceneDescription(doc).annotations.filter(
+			(a) => a.text?.animation === DESK_COVER_ANIMATION,
+		);
+		expect(rebuilt.map((a) => a.id)).toEqual(labels.map((a) => a.id));
+		expect(labels.map((a) => a.id)).toEqual(["desk-cf1-0", "desk-cf1-1"]);
+		for (const piece of scene.cameraFullscreenRegions) {
+			const own = labels.filter((a) => a.clipIndex === piece.clipIndex);
+			expect(own.map((a) => [a.startSec, a.endSec])).toEqual([[piece.startSec, piece.endSec]]);
+		}
+	});
+
+	it("adds no label when the translation is missing", () => {
+		vi.mocked(toastText).mockReturnValueOnce("settings.cameraFullscreen.deskLabel");
+		const doc = makeDoc({
+			legacyEditor: {
+				cameraFullscreenRegions: [{ id: "cf1", startMs: 0, endMs: 20_000, rotation: 180 }],
+			},
+		});
+		expect(
+			buildSceneDescription(doc).annotations.some(
+				(a) => a.text?.animation === DESK_COVER_ANIMATION,
+			),
+		).toBe(false);
+	});
+
 	it("keeps a region a trim removes entirely, marked underTrim", () => {
 		// Same rule as zoom and annotations (issue #216): addressed by the segment the cut
 		// interrupts (seg1, source [0,2] → clipIndex 0) instead of dropped. Full Camera needs
@@ -981,6 +1075,69 @@ describe("buildSceneDescription.cameraFullscreenRegions", () => {
 			{ startSec: 3, endSec: 5, clipIndex: 0, underTrim: true },
 		]);
 	});
+
+	it("sends a desk section turned, unmirrored and full-frame", () => {
+		const doc = makeDoc({
+			legacyEditor: {
+				webcamMirrored: true,
+				cameraFullscreenRegions: [{ id: "cf1", startMs: 2000, endMs: 5000, rotation: 180 }],
+			},
+		});
+		expect(buildSceneDescription(doc).cameraFullscreenRegions).toEqual([
+			{ startSec: 2, endSec: 5, rotation: 180, mirror: false, fullFrame: true },
+		]);
+	});
+
+	// The project mirror reaches the native side before the scene does, so a turned section
+	// that left its mirror to the project would flash mirrored for a frame when it changes.
+	it("pins a desk section's mirror even when it equals the project's", () => {
+		const doc = makeDoc({
+			legacyEditor: {
+				webcamMirrored: false,
+				cameraFullscreenRegions: [{ id: "cf1", startMs: 2000, endMs: 5000, rotation: 180 }],
+			},
+		});
+		expect(buildSceneDescription(doc).cameraFullscreenRegions).toEqual([
+			{ startSec: 2, endSec: 5, rotation: 180, mirror: false, fullFrame: true },
+		]);
+	});
+
+	it("sends nothing extra for a plain section, mirrored project or not", () => {
+		for (const webcamMirrored of [true, false]) {
+			const doc = makeDoc({
+				legacyEditor: {
+					webcamMirrored,
+					cameraFullscreenRegions: [{ id: "cf1", startMs: 2000, endMs: 5000 }],
+				},
+			});
+			expect(buildSceneDescription(doc).cameraFullscreenRegions).toEqual([
+				{ startSec: 2, endSec: 5 },
+			]);
+		}
+	});
+
+	it("sends an explicit mirror only when it differs from the project", () => {
+		const doc = makeDoc({
+			legacyEditor: {
+				webcamMirrored: true,
+				cameraFullscreenRegions: [{ id: "cf1", startMs: 0, endMs: 1000, mirror: "off" }],
+			},
+		});
+		expect(buildSceneDescription(doc).cameraFullscreenRegions).toEqual([
+			{ startSec: 0, endSec: 1, mirror: false },
+		]);
+	});
+
+	it("drops a rotation this build does not know", () => {
+		const doc = makeDoc({
+			legacyEditor: {
+				cameraFullscreenRegions: [{ id: "cf1", startMs: 0, endMs: 1000, rotation: 90 }],
+			},
+		});
+		expect(buildSceneDescription(doc).cameraFullscreenRegions).toEqual([
+			{ startSec: 0, endSec: 1 },
+		]);
+	});
 });
 
 // --- speedRegions -----------------------------------------------------------
diff --git a/src/native/sceneDescription.ts b/src/native/sceneDescription.ts
index 1f3d36314..731e61d37 100644
--- a/src/native/sceneDescription.ts
+++ b/src/native/sceneDescription.ts
@@ -23,9 +23,12 @@ import type {
 	WebcamBackgroundMode,
 } from "@/components/video-editor/types";
 import { DEFAULT_CROP_REGION, getZoomScale } from "@/components/video-editor/types";
+import { toastText } from "@/i18n/toastText";
 import { annotationFontSizeFraction } from "@/lib/ai-edition/annotationScale";
 import {
+	captionBackgroundCss,
 	captionCuesToTextRegions,
+	DEFAULT_CAPTION_SETTINGS,
 	deriveCaptionCues,
 	getCaptionSettings,
 	getCaptionTranslations,
@@ -51,6 +54,11 @@ import {
 	MAX_ZOOM_SCALE,
 	maxZoomScaleFor,
 } from "@/lib/ai-edition/timeline/zoom-scale";
+import {
+	normalizeCameraRotation,
+	resolveCameraOrientation,
+	showsDeskLabel,
+} from "@/lib/cameraOrientation";
 import {
 	computeCompositeLayout,
 	paddedContentSize,
@@ -60,6 +68,7 @@ import {
 	webcamSizeToFraction,
 } from "@/lib/compositeLayout";
 import type { CursorKind } from "@/lib/cursor/cursorThemes";
+import { DESK_COVER_ANIMATION, DESK_LABEL_Z_INDEX } from "@/lib/deskCover";
 import { parseCssGradient, resolveLinearGradientAngle } from "@/lib/exporter/gradientParser";
 import type { FrameTheme, RecordingFrame, WebcamAnchor } from "@/lib/projectDefaults";
 import { resolveTextFontFamily } from "@/lib/textFonts";
@@ -128,6 +137,12 @@ export interface SceneCameraFullscreenRegion {
 	/** See `SceneZoomRegion.underTrim`. Full-Camera needs no extra gate — its envelope is
 	 *  already contained in `[startSec, endSec]` — so this only carries the intent. */
 	underTrim?: boolean;
+	/** 180 for a desk shot; absent = not turned. */
+	rotation?: 180;
+	/** Mirror inside this section, sent only when it differs from `layout.webcamMirror`. */
+	mirror?: boolean;
+	/** Ignore the webcam crop inside this section (the whole camera frame). */
+	fullFrame?: true;
 }
 
 /** A speed region projected onto each clip's source time. The native compositor matches
@@ -766,6 +781,64 @@ export function webcamBoxSourceSize(
 	};
 }
 
+const DESK_LABEL_KEY = "cameraFullscreen.deskLabel";
+
+/** The translated label, or "" when the locale has no such key (`translate` echoes the key). */
+function deskLabelText(): string {
+	const text = toastText("settings", DESK_LABEL_KEY);
+	return text === `settings.${DESK_LABEL_KEY}` ? "" : text;
+}
+
+/**
+ * One caption-styled text region over every projected piece of a turned Full Camera section that
+ * shows its label (times already in source ms). It spans the whole piece: the compositor draws
+ * it at the camera cover's strength, so it is visible exactly while the cover is. Boxes are in
+ * percent of the frame, like the caption box.
+ * Ids come from the section's own id (`sectionId`) and the piece's clip — never from the
+ * piece's id, which the projection draws at random after the first piece — so a rebuild reuses
+ * them and the native text cache (keyed by id) does not grow.
+ */
+function deskLabelTextRegions(
+	pieces: (CameraFullscreenRegion & {
+		sectionId: string;
+		clipIndex?: number;
+		underTrim?: boolean;
+	})[],
+) {
+	const label = deskLabelText();
+	if (!label) return [];
+	return pieces.flatMap((region) => {
+		if (normalizeCameraRotation(region.rotation) !== 180 || !showsDeskLabel(region)) return [];
+		return [
+			{
+				space: "frame" as const,
+				verticalAlign: "center" as const,
+				id: `desk-${region.sectionId}-${region.clipIndex ?? "all"}`,
+				clipIndex: region.clipIndex,
+				...(region.underTrim ? { underTrim: true as const } : {}),
+				startMs: region.startMs,
+				endMs: region.endMs,
+				type: "text" as const,
+				content: label,
+				position: { x: 10, y: 40 },
+				size: { width: 80, height: 20 },
+				style: {
+					color: DEFAULT_CAPTION_SETTINGS.color,
+					backgroundColor: captionBackgroundCss(DEFAULT_CAPTION_SETTINGS),
+					fontSize: DEFAULT_CAPTION_SETTINGS.fontSize,
+					fontFamily: DEFAULT_CAPTION_SETTINGS.fontFamily,
+					fontWeight: DEFAULT_CAPTION_SETTINGS.fontWeight,
+					fontStyle: "normal" as const,
+					textDecoration: "none" as const,
+					textAlign: "center" as const,
+					textAnimation: DESK_COVER_ANIMATION,
+				},
+				zIndex: DESK_LABEL_Z_INDEX,
+			},
+		];
+	});
+}
+
 /** Serialize a document into a {@link SceneDescription}. Pure — no per-frame math. */
 export function buildSceneDescription(
 	document: AxcutDocument,
@@ -1026,6 +1099,16 @@ export function buildSceneDescription(
 		captionSettings,
 		captionAspect,
 	);
+	const projectedCameraFullscreenRegions = projectRegionsToSource(
+		(
+			((document.legacyEditor as Record<string, unknown> | null)?.cameraFullscreenRegions as
+				| CameraFullscreenRegion[]
+				| undefined) ?? []
+		).map((region) => ({ ...region, sectionId: region.id })),
+		visibleClips,
+		document.timeline.clips,
+		() => createId("camfull"),
+	);
 	const projectedAnnotations = projectRegionsToSource(
 		[
 			...(document.annotations ?? []),
@@ -1035,13 +1118,14 @@ export function buildSceneDescription(
 		document.timeline.clips,
 		() => createId("ann"),
 	);
-	const projectedCameraFullscreenRegions = projectRegionsToSource(
-		((document.legacyEditor as Record<string, unknown> | null)?.cameraFullscreenRegions as
-			| CameraFullscreenRegion[]
-			| undefined) ?? [],
-		visibleClips,
-		document.timeline.clips,
-		() => createId("camfull"),
+	// The desk-view label: caption-styled text over every PROJECTED piece of a turned section,
+	// drawn at the camera cover's strength (`annotation_text_state` in text_anim.rs). Per piece
+	// because the compositor covers each piece's own ends; the pieces are
+	// already in source time, so they are appended after the annotation projection, not through it.
+	projectedAnnotations.push(
+		...(deskLabelTextRegions(
+			projectedCameraFullscreenRegions,
+		) as unknown as typeof projectedAnnotations),
 	);
 	// Speed regions carry an extra `speed` field the standard `rangeSchema` does not, so we
 	// can't read from `document.timeline.speedRanges` today (see SceneDescription.speedRegions
@@ -1418,12 +1502,22 @@ export function buildSceneDescription(
 			})
 			// Ascending zIndex so the compositor paints in order without sorting per frame.
 			.sort((a, b) => a.zIndex - b.zIndex),
-		cameraFullscreenRegions: projectedCameraFullscreenRegions.map((region) => ({
-			startSec: region.startMs / 1000,
-			endSec: region.endMs / 1000,
-			clipIndex: region.clipIndex,
-			...(region.underTrim ? { underTrim: true } : {}),
-		})),
+		cameraFullscreenRegions: projectedCameraFullscreenRegions.map((region) => {
+			const orientation = resolveCameraOrientation(region, settings.webcamMirrored);
+			return {
+				startSec: region.startMs / 1000,
+				endSec: region.endMs / 1000,
+				clipIndex: region.clipIndex,
+				...(region.underTrim ? { underTrim: true } : {}),
+				...(orientation.rotation === 180 ? { rotation: 180 as const } : {}),
+				// A turned section always carries its mirror: the project mirror reaches the native
+				// side ahead of this scene, and falling back to it would flash mirrored text.
+				...(orientation.rotation === 180 || orientation.mirror !== settings.webcamMirrored
+					? { mirror: orientation.mirror }
+					: {}),
+				...(orientation.fullFrame ? { fullFrame: true as const } : {}),
+			};
+		}),
 		// Speed is the one modifier with nothing to show for itself on a parked playhead: a
 		// still frame has no rate. So the entries under a trim are dropped here rather than
 		// shipped inert — `speed_at` (regions.rs) matches on clipIndex + time with no window
diff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.md
index 9e95eb6a8..4f673be37 100644
--- a/technical-documentation/testing/manual-e2e-checklist.md
+++ b/technical-documentation/testing/manual-e2e-checklist.md
@@ -218,6 +218,7 @@ The helper waits up to 3 s for the camera's first visible frame before starting
 **Sharpness**
 
 - [ ] Take two recordings of one scene, holding a page of small printed text at arm's length: one at 640x480, from a camera that only offers 640x480 or from a release older than #875, and one at 1080p or 4K. Add a Full Camera segment over the same moment in each project, export MP4 at 1080p, extract a frame with `ffmpeg -ss <t> -i <export> -frames:v 1 frame.png`, and view both at 100%. The 1080p take resolves the text and the 640x480 take, upscaled about threefold, does not. With neither reference at hand, log `skipped: no 640x480 reference`.
+- [ ] Desk view. Tilt the webcam down onto a printed page with large text, record a few seconds, then tilt it back. In the editor add a Full Camera section over the tilted stretch and press *Desk view* in its inspector. The preview shows the page upright and readable, the pill carries the rotate icon, and outside the section the camera is as before. Turn the project's webcam mirror on and confirm the page still reads correctly inside the section. Export MP4 1080p, extract a frame from inside the section with `ffmpeg -ss <t> -i <export> -frames:v 1 frame.png`, and confirm the text is upright and not mirrored. `Ctrl+Z` once removes the desk view and leaves the plain Full Camera section. Tilting the camera down and back is hidden: the picture is blurred and dimmed with the translated *Desk mode* label at both ends of the section, and sharp in between; *Show label* off removes the text but keeps the blur.
 
 ### Several cameras (Windows)
 
@@ -869,6 +870,12 @@ On macOS 15.2+ it opens at launch, until it has been closed once, while one of i
 | 2026-10-03 | installed `v2.0.0-rc.13` (NSIS from the release, sha512 matched `latest.yml`), installed over rc.12 for all users, About reports `2.0.0-rc.13` | Windows 11 Home 26200, 1920×1080 @ 125 %, AMD Radeon iGPU, built-in USB2.0 HD UVC WebCam | Partial — 1 defect | **Scoped to the app changes between rc.8, the last computer-use pass, and rc.13**; the export path itself is covered by the rc.13 row above. Real OS mouse and keyboard input throughout; computer-use screenshots came back uniformly grey again, so the app was observed through `PrintWindow` on its own windows and DOM reads over CDP. **Defect: the webcam shows its first frame when a clip is entered past the webcam's last frame from another clip.** Two clips of one take (screen video 50.98 s, webcam 51.24 s, audio and clip 51.31 s): scrubbing from clip 2 to 51.2 s in clip 1 shows the screen's last frame, as 227b9b84 intends, but the webcam's frame 0 (2 of 2; ground truth from ffmpeg: an empty chair from 18.7 s to the end). Scrubbing to the same point from inside clip 1, or to 51.0 s from clip 2, shows the right webcam frame. Cause: `open_and_seek_clip` and `seek_pair` in `crates/compositor/src/live.rs` seek the webcam with `seek_to` and fall back to `seek_to(0.0)`, where `present_frame` uses `seek_to_or_last`; unchanged on `main`. Paused scrub only, in a ~70 ms window at the end of each clip. **Passed:** #961: one take with the countdown overlay, Record mode, editor work and an export, then closing the editor left 0 processes. #966: after rebinding *Add zoom* to Q and *Add audio* to J, the empty-lane hints read "Appuyez sur Q pour ajouter un zoom" and "Appuyez sur J pour ajouter un audio, V pour enregistrer une voix off", and Q adds a zoom. Wordmark menu in French: every row 31 px (one line), menu 261 px wide, "2.0.0-rc.13" in one piece. Preview: playback from 0:12 to 0:45.8 across a trim (0:15.0 → 0:18.5) and a 1.5× region with no canvas stall over 150 ms, 32–50 picture changes a second, wall time matching the edit; stops at 0:51.3 on the screen's and the webcam's last frames. #960 (#964): A → B → A with the playhead at 0:06, the preview is pixel-identical to before (mean difference 0, against 77.9 for project B). Background image → gradient → colour followed in the preview. #968: a media file whose read the OS refused (`icacls` deny on the test file) — *Regenerate* shows the translated "Impossible de lire l'audio de ce média…" hint inline and in the "Échec de la transcription" toast, without the IPC wrapper; the main process logs `MediaUnreadableError … Permission denied`. MP4 export from the GUI, 1752×1080 30 fps: 2930 frames, video 97.633 s against audio 97.666 s, zoom, background, webcam and cursor present in extracted frames, −18.3 LUFS. **Also seen:** the green "Aucune parole détectée" chip from the earlier successful run stays next to the unreadable hint; each clip of the take still carries 0.32 s of audio past its video (what is left of #942), and the export ends each clip at its video (97.63 s, against 98.22 s from the clip lengths the timeline shows). **Not run:** the HUD with no camera (#967; a camera is attached), the macOS HUD fix (c2a8559e), tray, microphone and system-audio content, GIF, macOS and Linux. |
 | 2026-10-03 | installed `v2.0.0-rc.13`, CI-built DMG `Openscreen-macOS-Apple-Silicon-2.0.0-rc.13.dmg` from the GitHub Release (tag `018d22ab`), installed over rc.12, `spctl`: accepted, Notarized Developer ID (M4LK7C6S84), About reports `2.0.0-rc.13` | macOS 26.5 (25F71), Mac mini M1, 3840×2160, no camera, no microphone | Partial, no defect | **Scoped to the app changes between rc.8 and rc.13, on macOS**: the Windows row above covers the same diff on Windows and leaves out #967, c2a8559e and macOS, which this row takes. Real OS mouse and keyboard input through computer-use (screenshots worked on this Mac); Apple's picker is owned by Control Centre and cannot be granted, so the operator clicked *Share Entire Screen* for each take. **c2a8559e (HUD kept out of takes after the editor round trip):** take 1 picked from the HUD's record button (`excludedWindowIds: [582]`), stop, editor, Record mode showed the source as *Choose what to record*, *Start recording* reopened Apple's picker instead of reusing the pick, take 2 recorded with `excludedWindowIds: [639]`; frames extracted from both files (28:26 and 13:04) show no HUD where it sat. **#967 (no camera on this Mac):** with `camEnabled: true` and no camera identity in `recording-settings.json`, launch rewrote it to `false` and the HUD showed the camera off; same with a stale identity (`camDeviceId` + `camDeviceName` of an unplugged camera); clicking the toggle keeps it off with the "Camera access is blocked" toast; Record mode reads *Camera Off*. **#961:** closing the editor after take 2 (countdown overlay, Record mode handover) left 0 processes; so did closing it after a long editor session (eight project opens through the native panel, transcriptions, Media mode, an export, the export dialog's save panel cancelled). **#966:** with *Add zoom* bound to X in `shortcuts.json`, the empty zoom lane reads "Press X to add zoom", and "Appuyez sur X pour ajouter un zoom" / "Drücke X, …" in French and German. **Wordmark menu (3bee2d25):** French and German, every row on one line, "2.0.0-rc.13" in one piece. **#960 (b834416c):** project A with captions → project B → A again: captions show at once at 0:06.4, 0:10.2 and 1:05.2 without touching *Show captions* (0:05.3 shows none, a 4.77 to 5.57 s silence in the saved words). **Preview:** playback from 0:12 to the end across four transcript silence cuts, a 2× and a 16× region: picture and captions follow, the readout advances with the edit, stops at 1:06.2; no stall seen, 8 `[pipeline] décodage` opens for one seek and four cuts (consistent with a preload per cut; not compared with rc.12). **227b9b84 / 83fbcecc:** a two-clip project whose first clip is a file with 8 s of video and 10 s of audio (no camera): seeking from clip 2 to 0:09.5 shows clip 1's last frame, the same as 0:07.7, no stderr. A video-only file plays with its picture (e73097c8). **#968:** project whose first asset is `chmod 000`: `MediaUnreadableError … Permission denied` in the main log, clip 2 still transcribed, the asset card shows "Transcription failed" and "Couldn't read this media's audio. Make sure OpenScreen can access the folder it's in, then regenerate." without the IPC wrapper; after `chmod 644`, *Regenerate* runs again (not persisted as no-audio). **Metal compositor (8caaa20d, dd5e914b, 0624c148, 2fb994eb):** laptop frame, 3D cursor, click impact, image background blurred 53 %, Aurora, captions; MP4 1080p60 export of 3374 frames, video and audio 56.23 s against 56.21 s computed (66.154 s minus 5.09 s of cuts minus the 2× and 16× gains), full decode clean; extracted frames show the laptop with its shadow, the blurred background, the 3D cursor with its shadow, rounded screen corners and captions. During playback the preview followed image → image, blur 52 → 1 %, image → colour and back. **Also seen:** the playhead keeps its time when another project is opened (0:41.0 from A shown in B and C). With a hand-written `camDeviceName` and a null `camDeviceId`, the HUD keeps the camera on and the file at `true` (`useCameraHudSync` compares the empty selection with the empty id and returns early); the app always writes both together, so this state is artificial. Out of scope: a 10 s extract with speech under loud video sound transcribes as no speech in Auto (detected `en`, p 0.35) and as "*Musique*" in French. **Not run:** webcam and microphone (none on this Mac), so the Windows row's webcam-past-the-end defect cannot be checked here; click impact not confirmed (the fixture's cursor sidecar has no clicks, and none was identified around the nine clicks of take 2 at preview scale); Aurora motion on a plain colour; the 4× preview lag of the rc.12 row (not re-measured: this pass played 2× and 16× regions without timing the lag); `Esc`; tray; GIF; A/B against rc.12; Gatekeeper (the DMG came through `gh`, no quarantine flag); Intel. |
 | 2026-10-03 | installed `v2.0.0-rc.15` (build run 37124242835, tag `ccd8b449`, NSIS sha512 matched `latest.yml`), installed over rc.12 for all users, About reports `2.0.0-rc.15` (`win32 x64 · nsis`, Electron 41.2.1, Chromium 146.0.7680.188, Node 24.14.1). `v2.0.0` was promoted from this candidate during the pass and differs from it only by the version bump (`eff86dcb`), so the results hold for the stable code | Windows 11 Home 26200, 1920×1080 @ 125 %, AMD Ryzen 5 7520U / Radeon iGPU, built-in USB2.0 HD UVC WebCam (best mode 1280×720@30), Microphone Array (AMD) | Partial — 6 defects | **Whole-file pass on Windows.** Real OS mouse and keyboard input throughout. Computer-use screenshots came back grey again, so the app was observed through `PrintWindow` on its own windows and DOM reads over CDP, and every picture and sound claim below was measured on the file with ffprobe/ffmpeg. **Defects:** (1) #1004, HUD drag at 125 %: the HUD window grows about 1.5 px per drag step (1180×882 → 1232×935 over ~43 steps) and the bar jumps by half the growth on release; after a long drag down the bar sat partly under the taskbar (centre y 1042, work area ends at 1032). (2) #1005, *Edit clip*: Reset, Cancel and Apply sit inside the scrolling body. In a 1240×1000 window (794 css px tall) the card is clipped above Apply, and a click where Apply should be lands on the backdrop, closing the dialog and discarding the edit. It fits when the window is maximized. (3) #1006, the rail's "Choose a clip to edit" menu renders under the timeline toolbar: Clip 2 and Clip 3 are covered (`elementFromPoint` returns `_tlToolbar`) and clicks on them do nothing. (4) #1007, a clip duplicated with Ctrl+C / Ctrl+V does not carry its anchored zoom or Full Camera region: `duplicateClip` in `src/lib/ai-edition/document/timeline.ts` copies only `trimRanges`. (5) #1008, zoom repel across a clip boundary: a zoom dragged into a neighbour that ends at its clip's end jumps past it into the next clip, shrinking from 12.97 to 8.23 s and leaving a zero-length fragment on the first clip. Ctrl+Z restores it. (6) #1009, the wordmark menu does not close on a click on the bare top bar. The header is a `-webkit-app-region: drag` area, which never delivers the document `mousedown` that `AppMenu` listens for. It does close on the preview, on a top-bar button and on the wordmark. **Passed: HUD and capture.** One HUD, `[content-protection] OFF` logged; horizontal ↔ vertical layout; every tooltip, idle and recording, beside or above the bar and unclipped; language menu (15 locales); camera and microphone toggles in one click; device settings: three inputs, level meter, live camera preview, camera quality row (1080p persisted across a relaunch; hand-edited 720p and an absent key both read 4K). Hide bar, then the tray overflow icon brings the HUD back; Quit leaves 0 processes; a second launch exits 0. With no source the record tooltip reads "Choose a screen or window to record" and one click opens the picker, then starts. While recording: source button disabled, toggles `aria-disabled`, gear inert, tray tooltip "Recording: Tout l'écran". Pause freezes the timer and resume advances it; restart starts a new helper and deletes the first file; cancel deletes the file and opens no editor. Stop opens the editor with "Recording added to a new project". Screen H.264 High bt709 1920×1080; AAC 48 kHz; webcam 1280×720 ~30 fps at 8 Mbit/s, the camera's best mode, not upscaled, matching `webcamFormat`. Microphone-only, system-audio-only and all-off takes behave; window source 1270×668, non-black; an odd 1001×601 window gives an even 992×596 file; a context menu inside the window is recorded and cut at its edge. Without the flag the HUD and an open Notes window are absent from the take. Record mode: rows, live camera preview, microphone meter, device switch, source modal with badge, *Start recording* hands over to the HUD; auto-zoom on gives one merged zoom over three clicks, off gives none, and the setting persists; editable cursor off hides the auto-zoom row and the Cursor facet; *Hide desktop icons* shows a bare wallpaper and restores the icons after. **Passed: editor.** Rename, Saved dot, tabs, chat panel toggle, tooltips with key chips, dividers; play, pause, seek playing and paused, ±1 frame arrows, stop at end; ruler click and drag, navigator narrow and pan, labels without collision, playhead within 0.5 px; Ctrl+S toast with a stable top bar. Clips: media card drag and *Add to timeline*, reorder, Edit clip grips, 1:1 crop held through a corner drag, Free, Cancel, pencil, delete. Trim, zoom (levels, custom, out-of-range message, focus drag, 3D modes), speed (presets, custom, 16× cap message, playback at 16×), annotation (text, sizes, plates, palette, Typewriter, image, arrow, blur mosaic and smooth, oval, clamped, dragged into padding); Ctrl+D, Ctrl+Z, Ctrl+Shift+Z. Modifiers inside a trim fire on the parked frame. Copy and paste of zoom, annotation and trim with their toasts and properties; an empty copy is a no-op; deleting a clip removes its modifiers; Edit clip clamps them; a Full Camera region across a junction splits and merges as clips move. Imported music: fragments across a junction with `offsetMs`, −18 dB and 1 s fades, gain, *Reset audio*; voiceover lands at the playhead. Transcript: clip order, silences, monotonic word seeks, live cue, Backspace skip and restore, silence trim; captions in four styles and six anchors; French translation with a *Display* row, and deleting it leaves the words untouched; typing in the packaged gate does nothing; a double-click correction survives *Regenerate as English* (model reused); 101 languages, detected language on the card. Composition: colour, gradient and one-colour gradient, wallpaper, animations move during playback only (21–23 distinct frames in 3 s, None 1), blur, 9:16 with Whole and Follow cursor, Auto padding with even borders, shadows, four frame styles in both themes. Camera layout: four presets, mirror, square, size (default 40, max 60), roundness, positions; background Cutout, Blur with an intensity slider, Custom image and colour, and the custom-colour mask reaches a 720p export; webcam crop corner zoom (124 %) and frame move. Audio facet: +6.5 dB raises the export from −17.2 to −12.7 LUFS with the peak held at −1.3 dBFS; reset returns 0 dB. Cursor facet: hide, style, size (to 5.8 of 6) and 3D cursor all show in the preview. Depth of field appears once a zoom has a 3D preset and changes the preview. Wordmark menu: rows as listed, About row version, arrows wrap both ways; Keyboard Shortcuts as one dialog: Z → Q changes the lane hint, Q adds a zoom, Z does nothing, reset restores Z; Ctrl+O; AI settings as one dialog; light and dark themes, dialogs included; French UI with one-line menu rows (#969), back to English; About lists the versions and channel, and Copy puts the same block on the clipboard; the HUD panel's version row and Check for Updates ("Checking…", disabled, the same dialog as the menu, re-enabled after). AI chat (deepseek): "add one zoom at 2x from 5 s to 8 s" lands as 5–8 s at 2.20× with the reason given, is undone by one Ctrl+Z and redone. Closing the editor quits the app and writes `editor-window.json` (`maximized: false`); after a relaunch the last project's settings and the main project's two clips, crop, regions, music, voiceover and captions are as left, and a paste before any copy changes nothing. A schema-4 project from July opens, migrates to schema 8, and keeps its clip, seven zooms and annotation. **Export:** MP4 1080p30 of the two-clip project, 10288 frames, audio and video within one frame, −16.0 LUFS and −1.4 dBTP, annotation upright, caption plate at x = 108 for a 10 % inset, Full Camera where mapped, music ducked about 10 dB under speech with fades at the track's own edges, muted track absent, voiceover not stretched by a 2× region. GIF 25 fps: cancel removes the partial file and leaves the existing destination untouched; the full render (~127 s, #952) gives 434 frames, infinite loop, consistent in ffmpeg and GDI+. **Also seen:** a take with a ~4 s pause had audio 1.09 s past its video, against 0.02–0.17 s without a pause; three dedicated paused takes gave 0.40, 0.15 and 0.03 s. The export ends each clip at its last video frame (10288 frames against the 10320 the progress counted), so the timeline and the export disagree by that tail. The editor reopens 4 px taller than it closed at 125 %. **Not run:** the A/V offset across a pause measured directly (the flash-and-beep rig never painted on the captured desktop), the HUD with no camera (needs the camera disabled in Windows), tray right-click menus (Update Settings, Stop Recording, Save Diagnostics: Explorer is granted click-only), the Alt Help menu (an Alt tap showed nothing, inconclusive), Ctrl/Shift+wheel on the timeline, cursor auto-hide, smoothing, motion blur and click effects, annotation animations other than Typewriter, Depth of field in an export, chat rewind, history and Smart cuts, a software-encoder take, the crackle and hole scan, multiple displays, 4K and 1440p cameras, 150 % DPI, macOS and Linux. |
+| 2026-10-02 | dev worktree `feat/camera-desk-view` @ `9cb5868c` (before this docs commit) | Windows 11 ARM64 (Snapdragon X Elite) | Partial — not run | **The new *Desk view* item was not run.** The authoring session had no computer-use, so no desk-view check was driven in the real app and nothing was exported or measured. Unit, type, lint and i18n checks only (see the commit). **Not covered:** the Desk view item itself (preview, rotate icon, mirror on, MP4 1080p frame, `Ctrl+Z`); Linux and macOS rendering, covered only by their CI Rust jobs. |
+| 2026-10-02 | dev worktree `feat/camera-desk-view` @ `2717908a`; `compositor_view.node` (ARM64, SHA256 `989a652e…7d2bb6`) built from this tree by `node scripts/build-windows-compositor-addon.mjs` (cargo up to date, no crate source newer than the DLL) and loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE`, ffmpeg DLLs from the vendored SDK on `PATH`; renderer rebuilt with `npm run build-vite`; own `--user-data-dir` | Windows 11 ARM64 (Snapdragon X Elite), h264_mf export | Partial — no defect | **The desk view turn on exported frames, through the app's real export (`electron . --user-data-dir=<dir> export <project> -o <mp4>`).** Source: 1920×1080 solid screen and a 1280×720 still `testsrc2` camera with a black-boxed `TOP-LEFT` drawtext in its top-left corner, 8 s. Four legacy 16:9 projects, padding, roundness and shadow 0, `--quality` from the project (`source`), one Full Camera section on [1 s, 7 s]; frame at 4 s against the camera frame at 4 s turned by ffmpeg and scaled to 1920×1080. Mean absolute RGB difference at 192×108 against identity / `hflip` / `vflip` / `hflip,vflip`: `rotation: 180`, project mirror **off** 222.77 / 28.19 / 222.32 / **5.99**; `rotation: 180`, project mirror **on** (section mirror absent = auto) the same four numbers, **5.99** for `hflip,vflip`; plain section, mirror **on** 222.30 / **6.00** / 222.76 / 28.19; plain section, mirror off (control) **5.99** / 222.31 / 28.19 / 222.77. The 6.0 floor is the same in every best match, the identity control included, so it is the encode and colour round trip, not geometry. Dark-pixel box (the text plate and the clock) at full size: both desk exports x 1063–1912, y 905–1071 against 1062–1912, 905–1071 for the turned source; plain mirrored 1063–1912, 8–174 against `hflip` 1062–1912, 8–174. At 0.5 s, outside the section, the PiP camera is upright. **Not run:** the live webcam pass with computer-use (preview, rotate icon on the pill, inspector, `Ctrl+Z`), a real tilted camera, a 4:3 camera, macOS and Linux rendering. |
+| 2026-10-02 | dev worktree `feat/camera-desk-view` @ `89b2f2b3`; `compositor_view.node` (ARM64, SHA256 `be85811d…728589f3`) rebuilt from this tree by `node scripts/build-windows-compositor-addon.mjs` and loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE`, ffmpeg DLLs from the vendored SDK on `PATH`; renderer rebuilt with `npm run build-vite`; own `--user-data-dir` | Windows 11 ARM64 (Snapdragon X Elite), h264_mf export | Partial — no defect | **The desk-view cover on exported frames, through the app's real export (`electron . --user-data-dir=<dir> export <project> -o <mp4>`).** Source: 1920×1080 solid screen and the same 1280×720 still `testsrc2` camera with its black-boxed `TOP-LEFT` drawtext (letters ~105 px tall in the output), 10 s. Two legacy 16:9 projects, padding, roundness and shadow 0, one Full Camera section on [1 s, 9 s] with `rotation: 180`, one of them with `deskLabel: false`. Frames at 1.5 s (start hold), 5.0 s (steady) and 8.7 s (end hold); the camera quad (52,26–1920,1080 at 1.5 s, 442,228–1914,1074 at 8.7 s, the Full Camera grow still running) is cropped and scaled back to 1920×1080 before measuring, inner region 40 px clear of the corners. **Steady 5.0 s:** mean absolute RGB difference at 192×108 against the `hflip,vflip` source **5.76** (encode floor, 5.99 in the row above); mean luma 1.002× the source. **Dim:** mean luma at 1.5 s / 8.7 s **0.642× / 0.642×** the 5.0 s frame (label off; 0.643 / 0.647 with the label). **Blur (label off):** 10–90 % width of a bar edge 2 px at 5.0 s and in the source, **44 px / 49 px** at 1.5 s / 8.7 s; variance of the 31 px high-pass 236.44 at 5.0 s, **2.45 / 2.28** (0.010× / 0.010×; 0.025× / 0.023× after dividing out the dim); Laplacian variance 69.16 at 5.0 s (109.79 source), 19.69 / 11.81 (0.28× / 0.17×, pixel-scale encoder noise keeps it from going lower). **Letters:** correlation of the plate's 31 px high-pass with the sharp source 0.996 at 5.0 s, **0.115 / 0.091** covered, against 0.02–0.03 for a 60 px misaligned control; at the 81 px band **0.534 / 0.522**; the mid-row letter contrast keeps 7.0 of 27.66 (≈ 0.39× after the dim). Turned upright, *TOP* still reads at 1.5 s and *LEFT* barely: the 4 % radius hides strokes, not ~105 px letters. **Label:** pixels with R, G, B all > 200 in the centre box (10/40/80/20 %): **3685 / 3713** at 1.5 s / 8.7 s, **0** at 5.0 s, **0** at 1.5 s and 8.7 s with `deskLabel: false`; between the two exports the frame above the box differs by 0.08 / 0.67 (mean abs RGB) and the blur numbers agree (edge 46 / 44 px, letter contrast 7.00 / 7.00 at 1.5 s), so switching the label off leaves the blur alone. **Not run:** the computer-use pass (live preview of the cover, *Show label* toggle, a real tilt with a printed page), the fade timing frame by frame, a 4:3 camera, macOS and Linux rendering. |
+| 2026-10-02 | dev worktree `feat/camera-desk-view` @ `7e505b54`; `compositor_view.node` (ARM64, SHA256 `5296ddf3…1298da`) built from this tree by `node scripts/build-windows-compositor-addon.mjs`, control addon (SHA256 `37d133a6…bb2f75`) built the same way with `regions.rs` and `shaders.hlsl` from `7aa3a0d9`, each loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE`, ffmpeg DLLs from the vendored SDK on `PATH`; renderer rebuilt with `npm run build-vite`; own `--user-data-dir` | Windows 11 ARM64 (Snapdragon X Elite), h264_mf export | Partial — no defect | **The desk-view cover re-measured on a 1080p camera, through the app's real export (`electron . --user-data-dir=<dir> export <project> -o <mp4>`).** Source: the 1920×1080 solid screen and the still `testsrc2` camera with a solid `#C8C8C8` band over its bottom 160 rows, as **1920×1080** (decoded into an aligned 1088-line texture) and 1280×720, 10 s. Legacy 16:9 projects, padding, roundness and shadow 0, `deskLabel: false`. **Edge band**, section [1 s, 9 s] `rotation: 180`, at the top of the turned quad (the bottom of the source), middle half of its width, mean luma of the outermost 12 rows against the next 12: 1080p **130.1 / 130.3** at 1.5 s and **129.8 / 129.8** at 8.7 s (rows 60–72: 130), G − (R+B)/2 between −1.8 and −0.3 (no green); 720p 130.1 / 129.9 and 129.8 / 130.1; 5.0 s (sharp) 200 / 200 everywhere. The control addon on the same 1080p export: **81.3 / 109.5** and **84.3 / 115.7** — the padding band the fix removes; 720p identical with both addons (no padding there). **2.6 s section** [1 s, 3.6 s], 1080p, mean luma of the centre 800×400 of the camera every 1/30 s from 1.8 s to 2.63 s: 83.2 (covered) → 85.2, 96.4, 111.6, 124.3, **127.5** at 2.167 s (the fades meet) → 118.4, 103.0, 89.2, 83.6 at 2.3 s, largest step **15.4** per frame, both ramps following the computed cover; the control addon climbs to 126.2 at 2.267 s and drops **43.0** in one frame to 83.2 at 2.3 s — the jump the fix removes. **Not run:** the computer-use pass (live preview, *Show label*), the label on a 1080p camera, a 4:3 camera, macOS and Linux rendering (WGSL validated with naga, Metal not compiled). |
+| 2026-10-03 | `2.0.0-rc.11` ARM64 test build from branch `local/v2.0-arm64` — rc.11 with the desk view and its tilt transition on top (branch head `87151b49` when this row was written) | Windows 11 ARM64 (Snapdragon X Elite), real webcam | Pass — no defect | **Desk view, run by the user on real hardware with a real webcam.** Tilted the webcam down onto a printed sheet and back up while recording. In the editor, a Full Camera section over the tilted stretch with *Desk view* on: blur, dim and the *Schreibtischmodus* label hid the tilt at both ends of the section, and in between the sheet was upright and sharp. The *Show label* switch removed and restored the text, and the MP4 export showed the same picture. The user's verdict: "works like a charm". **Not covered:** macOS, Linux. |
+| 2026-10-03 | dev worktree `feat/camera-desk-view` @ `81760851` (upstream `main` merged in at `ae3f116f`, plus a test-only fix); `compositor_view.node` (ARM64, SHA256 `2dfba38f…bdfec5f5`) built from the merged tree by `node scripts/build-windows-compositor-addon.mjs`, loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE`, ffmpeg DLLs from the vendored SDK on `PATH`; renderer rebuilt with `npm run build-vite`; own `--user-data-dir` | Windows 11 ARM64 (Snapdragon X Elite), h264_mf export | Partial — no defect | **The desk-view cover re-measured after the merge, because upstream reworked the layer shaders around it.** Exported with the app's real export (`electron . --user-data-dir=<dir> export <project> -o <mp4>`). Source: a 1920×1080 solid `#1E3F9F` screen and a still `testsrc2` camera at **1920×1080** with a solid `#C8C8C8` band over its bottom 160 rows, 10 s. Legacy 16:9 projects, padding, roundness and shadow 0, mirror off. One Full Camera section on [1 s, 9 s] with `rotation: 180`, exported with and without `deskLabel: false`, plus a 2.6 s section [1 s, 3.6 s]. **Steady 5.0 s:** mean absolute RGB difference at 192×108 against identity / `hflip` / `vflip` / `hflip,vflip` of the source **202.44 / 50.76 / 186.31 / 5.12**, so the best match is the turned source at the encode floor. Mean luma is 0.998× the source. **Cover** (label off; the camera quad is cropped and scaled back to 1920×1080, inner region 40 px clear of the corners): mean luma at 1.5 s / 8.7 s is **0.643× / 0.643×** the 5.0 s frame. Variance of the 31 px high-pass is 262.5 at 5.0 s and **2.10 / 1.99** at 1.5 s / 8.7 s (0.008× both). Laplacian variance is 124.9 at 5.0 s and 11.6 / 6.9 at 1.5 s / 8.7 s. **Edge band** at the top of the turned quad (52,27 at 1.5 s; 442,229 at 8.7 s), middle half of its width, mean luma of the outer 12 rows against the next 12: **130.4 / 130.0** and **129.8 / 130.0**, with G − (R+B)/2 between −1.8 and 0. That is no dark band and no green; 200 / 200 at 5.0 s. **Label:** pixels with R, G, B all > 200 in the output frame: **3691 / 3712** at 1.5 s / 8.7 s (box 820,506–1100,573), **0** at 5.0 s, and **0** at every sampled time with the label off. Outside the label box the two exports differ by at most 0.86 (mean abs RGB). **2.6 s section,** every 60 fps output frame from 1.8 s to 2.65 s, mean luma of the centre 800×400: 83.2 (covered) up to **127.5** at 2.15–2.167 s (the fades meet), then back to 83.6 at 2.3 s. The largest step is **7.9 per frame / 15.6 per 1/30 s**, the same curve as before the merge (127.5 peak, 15.4 per 1/30 s), with no one-frame jump. **Not run:** the computer-use pass, a 4:3 camera, macOS and Linux rendering (the WGSL is validated with naga for both `LAYER_MODELS` variants; Metal was not compiled). |
 | 2026-10-04 | dev `feat/multi-camera-recording` at `212c07f7` (feature head `23ea0751` + the HUD probe lint fix); `wgc-capture.exe` rebuilt from this tree by `npm run build:native:win` | Windows 11 on ARM64 (Snapdragon X Elite), one built-in camera (`AI Front Camera`), driven without computer-use | **Partial — the two-webcam run on site is outstanding; sub-project not complete until logged** | **Ran:** unit suite (`npm run test`, 304 of 305 files, the one failure `LeftPanel.copyMessage.test.tsx` passed alone, a load flake), both `tsc`, lint (0 errors, 26 warnings, the base count), `i18n:check`; the helper's native unit tests (`node scripts/build-windows-wgc-helper.mjs`, all pass); helper smoke runs `npm run test:wgc-helper:win`, `-- --webcam` and `-- --webcam --missing-second-webcam` (index 1 dropped and named, camera 1 kept); a direct helper run listing the one camera twice: camera 1 recorded, camera 2 dropped with `webcam-unavailable` index 1 and "already recording in this take", `webcamPaths` held one file, exit 0, camera file 4.81 s against the screen's 4.80 s. **Not run:** the app click-through (HUD *Additional cameras*, editor, save and reopen, the session manifest's `additionalWebcams`, the "Not recorded" notice): no computer-use here and only one camera. **Not covered at all:** two real cameras recording together, identical-name Brios, 1080p and 4K load, clap sync, macOS and Linux. |
 | 2026-10-05 | dev `feat/multi-camera-recording` at `86d49475`; `wgc-capture.exe` from `electron/native/wgc-capture/build` (4 Oct 13:05, `findstr` hit the fix-wave string *Could not remove the dropped camera file* and the control `encoder-selection`); `compositor_view.node` built from this tree by `npm run build:native:compositor` (ARM64) and loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE` next to the vendored win32-arm64 ffmpeg | Windows 11 on ARM64 (Snapdragon X Elite), **Logitech BRIO** (USB) + built-in `AI Front Camera`, 2560×1440 display | **Partial — two real cameras pass; Brio + C920, two identical Brios, 4K load and a mid-take camera loss not run yet** | *Helper:* Brio as camera 1 + built-in as camera 2 at 1080p30, 38 s take with three claps — both camera files 1146 frames / 38.19 s, screen 38.20 s at a steady 30 fps (`[pacing] frames=1146 elapsed_ms=38201`), camera 2 skipped the claimed Brio (`already recording in this take`), `webcamPaths` listed both. Clap sync by per-frame motion cross-correlation: 0 frames over the whole take, ≤ 1 frame (33 ms) per 3 s window; an 8-frame strip of the strongest clap shows the hands meeting and opening in the same frames on both. *App (HUD driven by the user):* Brio as camera 1, built-in ticked under *Additional cameras* — three files written, session `additionalWebcams` with label `AI Front Camera`, no *Not recorded* notice; Studio shows screen + camera 1 as before; the project holds `additionalCameraTracks` (1920×1080, offset 0, label) and keeps it after reopen, an edit and save. | The editor cannot select camera 2 yet — by design, sub-projects 2/3. First dev launch had no `compositor_view.node` in the worktree (blank Studio: `native addon not present`) — environment, not product. |
 | 2026-10-05 | dev `feat/multi-camera-recording` at `e0067391` (`fix(wgc): stop and report a camera that is unplugged mid-take`); `wgc-capture.exe` rebuilt by `npm run build:native:win`, `findstr` hit *Webcam lost during the take* and the control `encoder-selection` in `build` and `binwin32-x64` | Windows 11 on ARM64 (Snapdragon X Elite), **two Logitech BRIO** (identical names, USB instances `C&1EF69AFB` and `9&299A5C35`), **HD Pro Webcam C920**, built-in `AI Front Camera`; helper-level runs with a `webcams` list | **Partial — every on-site case passes at 1080p; 4K with a second camera paces cameras at 27.8 fps; the unplug notice was checked at helper level, not in the app UI** | *Brio + C920, 1080p:* 310/310/310 frames (camera 1, camera 2, screen). *Two identical Brios:* camera 2 skipped the claimed Brio (`already recording in this take`) and opened the other one — two different pictures; which Brio became camera 1 followed enumeration order, not intent (known limitation). *All four cameras at once, 1080p:* four different pictures, 392 frames each, screen 392 at a steady 30 fps. *4K:* one Brio alone 3840×2160 at 30 fps (401/401); two Brios requested at 4K → the Brio on a cheap USB cable only offers 1080p even alone (USB 2 link — hardware), and with 4K + 1080p both cameras paced at **27.8 fps** (363 frames in 13.07 s), screen 29.5 fps — all cameras are converted and encoded on the screen writer thread; follow-up: a worker thread per camera. *Unplug the C920 mid-take:* before the fix the C920 file ran on with a frozen picture and was still listed (`readFailures=737 lastReadHr=0xc00d3ea2`); after `e0067391` the helper logs `Webcam lost during the take: HD Pro Webcam C920 hr=0xc00d3ea2`, the C920 file ends at the loss (200 frames / 6.66 s), the Brio and screen run the full 27.7 s, and `webcamPaths` lists only the Brio — the input Electron turns into *Stopped early: …*. | The *Stopped early* toast itself was not watched in the app; it is unit-tested (`labelsOfWebcamsStoppedEarly`, renderer stop test). |

From f0bc3d1c69010a624819ab788d1fe1a971b57d2c Mon Sep 17 00:00:00 2001
From: Christian Schmittel <90287914+christian-wr@users.noreply.github.com>
Date: Mon, 5 Oct 2026 22:17:28 +0200
Subject: [PATCH 22/22] feat(camera): several cameras in the picture, with
 layout sections
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Up to four recorded cameras can now be on screen together. Layout sections on the
timeline choose a template — screen + small cameras, one camera full + small ones,
two cameras side by side, or another camera full — and which camera goes into each
place; the picture glides between sections. Each camera can be turned, mirrored,
cropped and perspective-corrected (a homography calibrated once with four corner
handles, optionally placed by detected ArUco markers from a printable sheet).

- Compositor: a list of camera layers per frame instead of one webcam rect,
  planned in `camera_layers.rs` (glide and fade between neighbouring sections,
  incl. a direct glide to and from an adjacent Full Camera section), extra camera
  decoders opened only for cameras a layout shows (preview and export, a camera
  that ends early never shortens the clip), a homography and a transparency lane in
  `LayerCB` (HLSL, WGSL, MSL), the corrected camera cover-fitted into its box.
- Editor: Full Camera regions stay as they are (camera 1, desk view); every other
  layout lives in `cameraLayoutRegions`, clip-anchored like Full Camera regions,
  in the same timeline lane with no overlap across the two lists. "Add layout"
  menu, a layout inspector (template, camera per place, reset windows), PiP places
  movable and resizable in the preview, a "Cameras" section with per-camera
  settings, and a calibration dialog (perspective and crop) with a loupe, target
  format, margin and a live rectified preview. Marker detection uses js-aruco2
  (MIT; the OpenCV 4x4 dictionary codes are BSD-3, both listed in
  THIRD-PARTY-NOTICES.md).
- Every change is one undo step; projects without layout sections render exactly
  as before.
---
 THIRD-PARTY-NOTICES.md                        |  47 +-
 crates/compositor-view-napi/src/lib.rs        |  64 +-
 crates/compositor/src/camera_layers.rs        | 476 +++++++++
 crates/compositor/src/compositor_linux.rs     | 461 +++++++--
 crates/compositor/src/compositor_macos.rs     | 268 +++--
 crates/compositor/src/compositor_windows.rs   | 303 ++++--
 crates/compositor/src/extra_cameras.rs        | 241 +++++
 crates/compositor/src/frame_geometry.rs       | 736 +++++++++++++-
 crates/compositor/src/gif_export.rs           |   2 +
 crates/compositor/src/lib.rs                  |   2 +
 crates/compositor/src/live.rs                 | 576 ++++++++++-
 crates/compositor/src/pipeline_linux.rs       |   7 +
 crates/compositor/src/pipeline_macos.rs       |   8 +
 crates/compositor/src/pipeline_windows.rs     |   7 +
 crates/compositor/src/regions.rs              | 152 ++-
 crates/compositor/src/scene.rs                | 152 +++
 crates/compositor/src/shaders.hlsl            |  39 +-
 crates/compositor/src/shaders.metal           |  79 +-
 crates/compositor/src/timeline_walk.rs        | 185 +++-
 crates/compositor/src/vk_shaders/layer.wgsl   |  57 +-
 crates/compositor/tests/compose_linux.rs      |   1 +
 crates/compositor/tests/export_timing.rs      |   1 +
 crates/poc-d3d/src/bench.rs                   |   2 +
 electron/ai-edition/agent-tools.test.ts       |  90 ++
 electron/ai-edition/agent-tools.ts            |  63 +-
 electron/ai-edition/deep-agent/service.ts     |   4 +-
 electron/ipc/nativeBridge.ts                  |   1 +
 .../services/compositorViewService.ts         |  12 +-
 electron/native/compositor-view/addon.d.ts    |  13 +
 package-lock.json                             |  10 +
 package.json                                  |   1 +
 scripts/editor-multicam-smoke.mjs             | 592 +++++++++++
 scripts/multicam-fixture.mjs                  | 933 ++++++++++++++++++
 src/cli/CliExportRunner.clipList.test.ts      |  71 ++
 src/cli/CliExportRunner.tsx                   |   7 +-
 .../CameraCalibrationModal.test.tsx           | 330 +++++++
 .../ai-edition/CameraCalibrationModal.tsx     | 711 +++++++++++++
 .../ai-edition/CamerasSection.test.tsx        | 185 ++++
 src/components/ai-edition/CamerasSection.tsx  | 245 +++++
 .../ai-edition/ExportDialog.params.test.tsx   |  44 +
 src/components/ai-edition/ExportDialog.tsx    |   5 +-
 .../NativeCompositorOverlay.test.tsx          |  31 +-
 .../ai-edition/NativeCompositorOverlay.tsx    |   4 +-
 .../ai-edition/NewEditorShell.module.css      |  20 +
 src/components/ai-edition/NewEditorShell.tsx  | 115 ++-
 src/components/ai-edition/Preview.tsx         |  19 +-
 .../PreviewCanvas.layoutPlaces.test.tsx       | 177 ++++
 src/components/ai-edition/PreviewCanvas.tsx   | 182 +++-
 src/components/ai-edition/RightPanes.tsx      |   9 +-
 .../ai-edition/v4/FloatingInspector.test.tsx  |  49 +-
 .../ai-edition/v4/FloatingInspector.tsx       | 170 ++--
 .../ai-edition/v4/LayoutSectionPane.test.tsx  | 129 +++
 .../ai-edition/v4/LayoutSectionPane.tsx       | 205 ++++
 .../v4/V4Timeline.geometry.test.tsx           |   7 +-
 .../ai-edition/v4/V4Timeline.layout.test.tsx  | 221 +++++
 src/components/ai-edition/v4/V4Timeline.tsx   | 145 ++-
 .../v4/V4Timeline.waveform.test.tsx           |   1 +
 .../ai-edition/v4/layoutTemplateUi.tsx        |  33 +
 src/components/ai-edition/v4/paneParts.tsx    | 105 ++
 src/components/video-editor/types.ts          |  55 ++
 src/i18n/locales/ar/dialogs.json              |  35 +
 src/i18n/locales/ar/editor.json               |   2 +
 src/i18n/locales/ar/settings.json             |  22 +
 src/i18n/locales/ar/timeline.json             |  19 +-
 src/i18n/locales/cs/dialogs.json              |  35 +
 src/i18n/locales/cs/editor.json               |   2 +
 src/i18n/locales/cs/settings.json             |  22 +
 src/i18n/locales/cs/timeline.json             |  19 +-
 src/i18n/locales/de/dialogs.json              |  35 +
 src/i18n/locales/de/editor.json               |   2 +
 src/i18n/locales/de/settings.json             |  22 +
 src/i18n/locales/de/timeline.json             |  19 +-
 src/i18n/locales/en/dialogs.json              |  35 +
 src/i18n/locales/en/editor.json               |   2 +
 src/i18n/locales/en/settings.json             |  22 +
 src/i18n/locales/en/timeline.json             |  19 +-
 src/i18n/locales/es/dialogs.json              |  35 +
 src/i18n/locales/es/editor.json               |   2 +
 src/i18n/locales/es/settings.json             |  22 +
 src/i18n/locales/es/timeline.json             |  19 +-
 src/i18n/locales/fr/dialogs.json              |  35 +
 src/i18n/locales/fr/editor.json               |   2 +
 src/i18n/locales/fr/settings.json             |  22 +
 src/i18n/locales/fr/timeline.json             |  19 +-
 src/i18n/locales/it/dialogs.json              |  35 +
 src/i18n/locales/it/editor.json               |   2 +
 src/i18n/locales/it/settings.json             |  22 +
 src/i18n/locales/it/timeline.json             |  19 +-
 src/i18n/locales/ja-JP/dialogs.json           |  35 +
 src/i18n/locales/ja-JP/editor.json            |   2 +
 src/i18n/locales/ja-JP/settings.json          |  22 +
 src/i18n/locales/ja-JP/timeline.json          |  19 +-
 src/i18n/locales/ko-KR/dialogs.json           |  35 +
 src/i18n/locales/ko-KR/editor.json            |   2 +
 src/i18n/locales/ko-KR/settings.json          |  22 +
 src/i18n/locales/ko-KR/timeline.json          |  19 +-
 src/i18n/locales/pt-BR/dialogs.json           |  35 +
 src/i18n/locales/pt-BR/editor.json            |   2 +
 src/i18n/locales/pt-BR/settings.json          |  22 +
 src/i18n/locales/pt-BR/timeline.json          |  19 +-
 src/i18n/locales/ru/dialogs.json              |  35 +
 src/i18n/locales/ru/editor.json               |   2 +
 src/i18n/locales/ru/settings.json             |  22 +
 src/i18n/locales/ru/timeline.json             |  19 +-
 src/i18n/locales/tr/dialogs.json              |  35 +
 src/i18n/locales/tr/editor.json               |   2 +
 src/i18n/locales/tr/settings.json             |  22 +
 src/i18n/locales/tr/timeline.json             |  19 +-
 src/i18n/locales/vi/dialogs.json              |  35 +
 src/i18n/locales/vi/editor.json               |   2 +
 src/i18n/locales/vi/settings.json             |  22 +
 src/i18n/locales/vi/timeline.json             |  19 +-
 src/i18n/locales/zh-CN/dialogs.json           |  35 +
 src/i18n/locales/zh-CN/editor.json            |   2 +
 src/i18n/locales/zh-CN/settings.json          |  22 +
 src/i18n/locales/zh-CN/timeline.json          |  19 +-
 src/i18n/locales/zh-TW/dialogs.json           |  35 +
 src/i18n/locales/zh-TW/editor.json            |   2 +
 src/i18n/locales/zh-TW/settings.json          |  22 +
 src/i18n/locales/zh-TW/timeline.json          |  19 +-
 src/lib/ai-edition/document/timeline.test.ts  |  67 ++
 src/lib/ai-edition/document/timeline.ts       |  38 +-
 .../store/documentWriteAudit.test.ts          |  16 +-
 src/lib/ai-edition/store/regionClipboard.ts   |   1 +
 .../store/regionClipboardKinds.test.ts        |  62 ++
 .../ai-edition/store/regionClipboardKinds.ts  |  89 ++
 src/lib/ai-edition/store/useTimeline.test.ts  | 492 ++++++++-
 src/lib/ai-edition/store/useTimeline.ts       | 527 +++++++++-
 .../timeline/calibrationGeometry.test.ts      | 154 +++
 .../timeline/calibrationGeometry.ts           | 183 ++++
 src/lib/ai-edition/timeline/camera.test.ts    |  35 +-
 src/lib/ai-edition/timeline/camera.ts         |  15 +
 .../ai-edition/timeline/cameraList.test.ts    | 101 ++
 src/lib/ai-edition/timeline/cameraList.ts     |  77 ++
 .../timeline/cameraSectionNotice.test.ts      |  22 +
 .../timeline/cameraSectionNotice.ts           |  36 +
 src/lib/ai-edition/timeline/grabFrame.test.ts | 100 ++
 src/lib/ai-edition/timeline/grabFrame.ts      |  97 ++
 .../ai-edition/timeline/layoutMenu.test.ts    |  71 ++
 src/lib/ai-edition/timeline/layoutMenu.ts     |  86 ++
 .../timeline/layoutSlotDrag.test.ts           | 134 +++
 src/lib/ai-edition/timeline/layoutSlotDrag.ts | 123 +++
 src/lib/arucoMarkers.test.ts                  | 189 ++++
 src/lib/arucoMarkers.ts                       | 138 +++
 src/lib/cameraLayoutTemplates.test.ts         | 136 +++
 src/lib/cameraLayoutTemplates.ts              | 105 ++
 src/lib/cameraLayouts.test.ts                 | 299 ++++++
 src/lib/cameraLayouts.ts                      | 256 +++++
 src/lib/cameraPerspective.test.ts             |  85 ++
 src/lib/cameraPerspective.ts                  |  67 ++
 src/lib/markerSheet.test.ts                   | 106 ++
 src/lib/markerSheet.ts                        | 144 +++
 src/native/compositorViewClient.ts            |  12 +-
 src/native/contracts.ts                       |  12 +
 src/native/sceneDescription.test.ts           | 435 ++++++++
 src/native/sceneDescription.ts                | 292 +++++-
 src/types/js-aruco2.d.ts                      |  53 +
 .../testing/manual-e2e-checklist.md           |  27 +
 158 files changed, 14249 insertions(+), 663 deletions(-)
 create mode 100644 crates/compositor/src/camera_layers.rs
 create mode 100644 crates/compositor/src/extra_cameras.rs
 create mode 100644 scripts/editor-multicam-smoke.mjs
 create mode 100644 scripts/multicam-fixture.mjs
 create mode 100644 src/cli/CliExportRunner.clipList.test.ts
 create mode 100644 src/components/ai-edition/CameraCalibrationModal.test.tsx
 create mode 100644 src/components/ai-edition/CameraCalibrationModal.tsx
 create mode 100644 src/components/ai-edition/CamerasSection.test.tsx
 create mode 100644 src/components/ai-edition/CamerasSection.tsx
 create mode 100644 src/components/ai-edition/PreviewCanvas.layoutPlaces.test.tsx
 create mode 100644 src/components/ai-edition/v4/LayoutSectionPane.test.tsx
 create mode 100644 src/components/ai-edition/v4/LayoutSectionPane.tsx
 create mode 100644 src/components/ai-edition/v4/V4Timeline.layout.test.tsx
 create mode 100644 src/components/ai-edition/v4/layoutTemplateUi.tsx
 create mode 100644 src/components/ai-edition/v4/paneParts.tsx
 create mode 100644 src/lib/ai-edition/store/regionClipboardKinds.test.ts
 create mode 100644 src/lib/ai-edition/store/regionClipboardKinds.ts
 create mode 100644 src/lib/ai-edition/timeline/calibrationGeometry.test.ts
 create mode 100644 src/lib/ai-edition/timeline/calibrationGeometry.ts
 create mode 100644 src/lib/ai-edition/timeline/cameraList.test.ts
 create mode 100644 src/lib/ai-edition/timeline/cameraList.ts
 create mode 100644 src/lib/ai-edition/timeline/cameraSectionNotice.test.ts
 create mode 100644 src/lib/ai-edition/timeline/cameraSectionNotice.ts
 create mode 100644 src/lib/ai-edition/timeline/grabFrame.test.ts
 create mode 100644 src/lib/ai-edition/timeline/grabFrame.ts
 create mode 100644 src/lib/ai-edition/timeline/layoutMenu.test.ts
 create mode 100644 src/lib/ai-edition/timeline/layoutMenu.ts
 create mode 100644 src/lib/ai-edition/timeline/layoutSlotDrag.test.ts
 create mode 100644 src/lib/ai-edition/timeline/layoutSlotDrag.ts
 create mode 100644 src/lib/arucoMarkers.test.ts
 create mode 100644 src/lib/arucoMarkers.ts
 create mode 100644 src/lib/cameraLayoutTemplates.test.ts
 create mode 100644 src/lib/cameraLayoutTemplates.ts
 create mode 100644 src/lib/cameraLayouts.test.ts
 create mode 100644 src/lib/cameraLayouts.ts
 create mode 100644 src/lib/cameraPerspective.test.ts
 create mode 100644 src/lib/cameraPerspective.ts
 create mode 100644 src/lib/markerSheet.test.ts
 create mode 100644 src/lib/markerSheet.ts
 create mode 100644 src/types/js-aruco2.d.ts

diff --git a/THIRD-PARTY-NOTICES.md b/THIRD-PARTY-NOTICES.md
index f80ec2361..b2611d75b 100644
--- a/THIRD-PARTY-NOTICES.md
+++ b/THIRD-PARTY-NOTICES.md
@@ -6,7 +6,9 @@ application resources and satisfies the attribution and source-offer obligations
 that come with them.
 
 npm dependencies are not listed here: they are resolved from `package.json` and
-distributed by their own registries, not redistributed inside our binaries.
+distributed by their own registries, not redistributed inside our binaries. The
+exception is code bundled into the renderer whose licence asks for its notice in
+the distributed form (js-aruco2 below): the bundler strips the source headers.
 
 ---
 
@@ -172,6 +174,49 @@ distributed by their own registries, not redistributed inside our binaries.
   notice as OpenScreen's own [LICENSE](LICENSE). Published by Recordly under MIT,
   before its relicensing in March 2026.
 
+## js-aruco2 — ArUco marker detection
+
+- **Components**: `src/aruco.js` and `src/cv.js` of the npm package `js-aruco2`
+  2.0.0, compiled into the renderer bundle (`dist/assets/*.js`).
+- **Used by**: the camera calibration dialog, which finds the four printed corner
+  markers in a camera still.
+- **License**: MIT — Copyright (c) 2020 Damiano Falcioni, Copyright (c) 2011 Juan
+  Mellado, under the same permission notice as OpenScreen's own
+  [LICENSE](LICENSE).
+- **Upstream**: <https://github.com/damianofalcioni/js-aruco2>, release 2.0.0.
+
+## OpenCV — ArUco 4×4 dictionary codes
+
+- **Component**: the marker codes in js-aruco2's
+  `src/dictionaries/aruco_4x4_1000.js`, compiled into the renderer bundle. They
+  are taken from OpenCV's `predefined_dictionaries.hpp`; the marker sheet the
+  editor prints draws markers 0–3 of this dictionary.
+- **License**: BSD 3-Clause — Copyright (C) 2013, OpenCV Foundation, all rights
+  reserved. Third party copyrights are property of their respective owners.
+
+  > Redistribution and use in source and binary forms, with or without
+  > modification, are permitted provided that the following conditions are met:
+  >
+  > - Redistributions of source code must retain the above copyright notice,
+  >   this list of conditions and the following disclaimer.
+  > - Redistributions in binary form must reproduce the above copyright notice,
+  >   this list of conditions and the following disclaimer in the documentation
+  >   and/or other materials provided with the distribution.
+  > - Neither the names of the copyright holders nor the names of the
+  >   contributors may be used to endorse or promote products derived from this
+  >   software without specific prior written permission.
+  >
+  > This software is provided by the copyright holders and contributors "as is"
+  > and any express or implied warranties, including, but not limited to, the
+  > implied warranties of merchantability and fitness for a particular purpose
+  > are disclaimed. In no event shall copyright holders or contributors be liable
+  > for any direct, indirect, incidental, special, exemplary, or consequential
+  > damages (including, but not limited to, procurement of substitute goods or
+  > services; loss of use, data, or profits; or business interruption) however
+  > caused and on any theory of liability, whether in contract, strict liability,
+  > or tort (including negligence or otherwise) arising in any way out of the use
+  > of this software, even if advised of the possibility of such damage.
+
 ## Rust crates — compiled into the compositor addon
 
 - **Component**: `compositor_view.node`, under
diff --git a/crates/compositor-view-napi/src/lib.rs b/crates/compositor-view-napi/src/lib.rs
index 905a6a5e5..5a1ded0e1 100644
--- a/crates/compositor-view-napi/src/lib.rs
+++ b/crates/compositor-view-napi/src/lib.rs
@@ -15,7 +15,7 @@ use openscreen_compositor::frame_geometry::FootageQuad;
 use openscreen_compositor::gif_export::{GifExportParams, GifStats};
 use openscreen_compositor::gif_export_control::{GifExportCancelled, GifExportControl};
 use openscreen_compositor::live::{LiveView, PausedPreviews};
-use openscreen_compositor::scene::Scene;
+use openscreen_compositor::scene::{Scene, SceneClipCamera};
 use openscreen_compositor::{config, pipeline};
 use std::collections::HashMap;
 use std::path::PathBuf;
@@ -368,6 +368,9 @@ pub fn present_time(id: i32, seconds: f64) {
 /// Remplace les sources du clip actif sans recréer la vue ni son thread de rendu. L'identité
 /// timeline et le playhead source sont atomiques avec le switch : deux clips partageant les
 /// mêmes fichiers restent distincts, et les deux décodeurs ouvrent directement la bonne frame.
+///
+/// `additional_cameras`: cameras 2-4 of the clip (index k-1 = camera k, an empty `path` = no
+/// camera in that slot). Absent = none; the view decodes only those its layout regions show.
 #[napi]
 pub fn set_active_clip(
     id: i32,
@@ -376,18 +379,33 @@ pub fn set_active_clip(
     webcam_offset_sec: f64,
     clip_index: u32,
     source_time_sec: f64,
+    additional_cameras: Option<Vec<ClipCameraInput>>,
 ) {
     if let Some(v) = registry().lock().unwrap().get(&id) {
+        let cameras = additional_cameras
+            .unwrap_or_default()
+            .into_iter()
+            .map(|c| SceneClipCamera { path: c.path, offset_sec: c.offset_sec })
+            .collect();
         v.set_active_clip(
             &screen_path,
             &webcam_path,
             webcam_offset_sec,
+            cameras,
             clip_index as usize,
             source_time_sec,
         );
     }
 }
 
+/// An additional camera of a clip (= TS `CompositorClipCamera`).
+#[napi(object)]
+pub struct ClipCameraInput {
+    pub path: String,
+    /// Camera source time = screen source time - this.
+    pub offset_sec: f64,
+}
+
 /// Installe la scène de l'app (JSON `SceneDescription`) sur la vue : layout preset piloté par
 /// l'app au lieu de la fixture. JSON invalide → ignoré côté natif.
 #[napi]
@@ -504,6 +522,26 @@ pub struct ClipInput {
     pub webcam_offset_sec: f64,
     /// `false` évite une ouverture ffmpeg vouée à échouer et réserve du silence à ce clip.
     pub has_audio: bool,
+    /// Cameras 2-4 of the clip (index k-1 = camera k, an empty `path` = none). Absent = none.
+    pub additional_cameras: Option<Vec<ClipCameraInput>>,
+}
+
+/// `ClipInput` → `pipeline::ClipSource`, shared by the MP4 and the GIF export.
+fn clip_source(c: ClipInput) -> pipeline::ClipSource {
+    pipeline::ClipSource {
+        screen: c.screen_path,
+        webcam: c.webcam_path,
+        source_start_sec: c.source_start_sec,
+        source_end_sec: c.source_end_sec,
+        webcam_offset_sec: c.webcam_offset_sec,
+        has_audio: c.has_audio,
+        additional_cameras: c
+            .additional_cameras
+            .unwrap_or_default()
+            .into_iter()
+            .map(|cam| pipeline::ClipCamera { path: cam.path, offset_sec: cam.offset_sec })
+            .collect(),
+    }
 }
 
 /// The export's pixel size. The SHAPE belongs to the scene: `scene.output` is what the live
@@ -701,17 +739,7 @@ pub fn export_multi(
     params: Option<ExportParamsInput>,
     on_progress: Option<JsFunction>,
 ) -> Result<AsyncTask<ExportMultiTask>> {
-    let clips = clips
-        .into_iter()
-        .map(|c| pipeline::ClipSource {
-            screen: c.screen_path,
-            webcam: c.webcam_path,
-            source_start_sec: c.source_start_sec,
-            source_end_sec: c.source_end_sec,
-            webcam_offset_sec: c.webcam_offset_sec,
-            has_audio: c.has_audio,
-        })
-        .collect();
+    let clips = clips.into_iter().map(clip_source).collect();
     Ok(AsyncTask::new(ExportMultiTask {
         out_path,
         clips,
@@ -882,17 +910,7 @@ pub fn export_gif(
     // Deliberately the same argument shape as `export_multi`: the caller builds
     // one clip list and one scene, and picks the container. Cursor comes from
     // the scene like every other effect — there is no GIF-specific input left.
-    let clips = clips
-        .into_iter()
-        .map(|c| pipeline::ClipSource {
-            screen: c.screen_path,
-            webcam: c.webcam_path,
-            source_start_sec: c.source_start_sec,
-            source_end_sec: c.source_end_sec,
-            webcam_offset_sec: c.webcam_offset_sec,
-            has_audio: c.has_audio,
-        })
-        .collect();
+    let clips = clips.into_iter().map(clip_source).collect();
     let gif_params = params
         .map(|p| GifExportParams {
             width: p.width,
diff --git a/crates/compositor/src/camera_layers.rs b/crates/compositor/src/camera_layers.rs
new file mode 100644
index 000000000..ed5447b97
--- /dev/null
+++ b/crates/compositor/src/camera_layers.rs
@@ -0,0 +1,476 @@
+//! Which camera layers a frame draws, and where, inside camera layout regions.
+//!
+//! Pure planning: `plan_frame` calls `camera_layers_at` and the backends draw the result. A
+//! region's layers glide in from whatever was on screen before it (the default camera-1 PiP,
+//! or the layers of a region that ends exactly where it starts) and glide back out to the
+//! default, on the Full Camera envelope (`regions::camera_fullscreen_region_phase`): the same
+//! window lengths, the same `ease_out_screen_studio` curve, measured on the screen clock. A
+//! camera-1 Full Camera region that meets a layout region at a seam is a neighbour like any
+//! other: camera 0 frame-filling, gliding straight into or out of the layout region's layers.
+
+use crate::frame_geometry::webcam_shape_code;
+use crate::regions::{
+    ease_out_screen_studio, ScreenClock, FULLSCREEN_LEAD_OUT_WINDOW_S, REGION_SEAM_S,
+    TRANSITION_WINDOW_S,
+};
+use crate::scene::{SceneCameraFullscreenRegion, SceneCameraLayer, SceneCameraLayoutRegion};
+
+/// Two regions closer than this (source seconds) hand over directly, without the default.
+const ADJACENT_S: f64 = REGION_SEAM_S;
+/// Layers fainter than this are not drawn at all.
+const MIN_OPACITY: f32 = 1e-3;
+/// Cameras beyond camera 0 a compositor takes frames for (`set_extra_camera_frames`).
+pub const MAX_EXTRA_CAMERAS: usize = 3;
+
+/// One camera to draw this frame.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct CameraLayerPlan {
+    pub camera: usize,
+    /// x, y, w, h in output fractions.
+    pub dst: [f32; 4],
+    /// Corner radius as a fraction of min(dst w, h) in pixels.
+    pub radius_frac: f32,
+    /// `webcam_shape_code` vocabulary.
+    pub shape: u32,
+    /// 0..1.
+    pub opacity: f32,
+    pub fills_frame: bool,
+}
+
+fn plan_of(layer: &SceneCameraLayer) -> CameraLayerPlan {
+    let r = layer.rect;
+    CameraLayerPlan {
+        camera: layer.camera,
+        dst: [r.x, r.y, r.width, r.height],
+        radius_frac: layer.radius_frac,
+        shape: webcam_shape_code(&layer.shape),
+        opacity: 1.0,
+        fills_frame: layer.fills_frame,
+    }
+}
+
+fn lerp(a: f32, b: f32, k: f32) -> f32 {
+    a + (b - a) * k
+}
+
+/// `a` turning into `b` at `k` (0 = all `a`, 1 = all `b`). A camera in both moves; a camera in
+/// only one of them fades. Draw order: frame-filling layers first, then the rest, each group in
+/// `b`'s order followed by what only `a` still shows.
+fn blend(a: &[CameraLayerPlan], b: &[CameraLayerPlan], k: f32) -> Vec<CameraLayerPlan> {
+    let k = k.clamp(0.0, 1.0);
+    let mut out = Vec::with_capacity(a.len() + b.len());
+    for to in b {
+        out.push(match a.iter().find(|from| from.camera == to.camera) {
+            Some(from) => {
+                // Discrete properties switch half-way through the move.
+                let flags = if k >= 0.5 { to } else { from };
+                CameraLayerPlan {
+                    camera: to.camera,
+                    dst: std::array::from_fn(|i| lerp(from.dst[i], to.dst[i], k)),
+                    radius_frac: lerp(from.radius_frac, to.radius_frac, k),
+                    shape: flags.shape,
+                    opacity: 1.0,
+                    fills_frame: flags.fills_frame,
+                }
+            }
+            None => CameraLayerPlan { opacity: k, ..*to },
+        });
+    }
+    for from in a {
+        if !b.iter().any(|to| to.camera == from.camera) {
+            out.push(CameraLayerPlan { opacity: 1.0 - k, ..*from });
+        }
+    }
+    out.retain(|layer| layer.opacity > MIN_OPACITY);
+    // Stable: each group keeps the order built above.
+    out.sort_by_key(|layer| !layer.fills_frame);
+    out
+}
+
+/// Camera 0 as a Full Camera region shows it: the whole frame, square corners. Same discrete
+/// shape as the default layer, so the hand-over to the default inside the region is seamless.
+fn full_camera_layer(default: &CameraLayerPlan) -> CameraLayerPlan {
+    CameraLayerPlan {
+        camera: 0,
+        dst: [0.0, 0.0, 1.0, 1.0],
+        radius_frac: 0.0,
+        shape: default.shape,
+        opacity: 1.0,
+        fills_frame: true,
+    }
+}
+
+/// The layers to draw at source time `t`, in draw order.
+///
+/// `default_cam0`: camera 0's layer as today's plan places it (None = camera 0 not drawn). It
+/// is what shows outside every region, and what a region glides from and back to.
+///
+/// `fullscreen`: the camera-1 Full Camera regions. One that meets a layout region at a seam
+/// is that region's neighbour, with camera 0 frame-filling: the layout region glides in from
+/// it, or holds to its end and the Full Camera region's lead-in glides on from its layers
+/// (the Full Camera phase holds 1 on that side, `regions::camera_fullscreen_region_phase`).
+///
+/// Time base: copied from `camera_fullscreen_region_phase` — the region is found on SOURCE
+/// time (its bounds compared to `t` as `f32`), then the windows are measured on the SCREEN
+/// clock (`clock.at`), so a speed region does not stretch or squash the glide.
+pub fn camera_layers_at(
+    regions: &[SceneCameraLayoutRegion],
+    fullscreen: &[SceneCameraFullscreenRegion],
+    t: f32,
+    clock: &ScreenClock,
+    default_cam0: Option<CameraLayerPlan>,
+) -> Vec<CameraLayerPlan> {
+    let default: Vec<CameraLayerPlan> = default_cam0.into_iter().collect();
+    let full_cam0: Vec<CameraLayerPlan> = default_cam0.iter().map(full_camera_layer).collect();
+    // An empty (or reversed) region would match `t` at a single instant and draw its layers
+    // at full strength for that sample; it is neither drawn nor anyone's neighbour.
+    let non_empty = || regions.iter().enumerate().filter(|(_, r)| r.end_sec > r.start_sec);
+    let full_cameras = || fullscreen.iter().filter(|r| r.end_sec > r.start_sec);
+    let layers_of = |r: &SceneCameraLayoutRegion| r.layers.iter().map(plan_of).collect::<Vec<_>>();
+    let Some(index) = non_empty()
+        .find(|(_, r)| r.start_sec as f32 <= t && t <= r.end_sec as f32)
+        .map(|(i, _)| i)
+    else {
+        return full_camera_lead_in(regions, fullscreen, t, clock, &full_cam0).unwrap_or(default);
+    };
+    let region = &regions[index];
+    let others = || non_empty().filter(move |(i, _)| *i != index).map(|(_, r)| r);
+    let prev = others()
+        .find(|r| (r.end_sec - region.start_sec).abs() <= ADJACENT_S)
+        .map(layers_of)
+        .or_else(|| {
+            full_cameras()
+                .any(|f| (f.end_sec - region.start_sec).abs() <= ADJACENT_S)
+                .then(|| full_cam0.clone())
+        });
+    let has_next = others().any(|r| (r.start_sec - region.end_sec).abs() <= ADJACENT_S)
+        || full_cameras().any(|f| (f.start_sec - region.end_sec).abs() <= ADJACENT_S);
+    let current = layers_of(region);
+
+    let (start, end, t) = (
+        clock.at(region.start_sec as f32),
+        clock.at(region.end_sec as f32),
+        clock.at(t),
+    );
+    let half = (end - start) * 0.5;
+    let win_in = TRANSITION_WINDOW_S.min(half);
+    let win_out = FULLSCREEN_LEAD_OUT_WINDOW_S.min(half);
+    if t - start < win_in {
+        let from = prev.as_deref().unwrap_or(&default);
+        blend(from, &current, ease_out_screen_studio((t - start) / win_in))
+    } else if !has_next && end - t < win_out {
+        // With a region right after this one, the hand-over is that region's lead-in instead.
+        blend(&current, &default, 1.0 - ease_out_screen_studio((end - t) / win_out))
+    } else {
+        blend(&[], &current, 1.0)
+    }
+}
+
+/// Inside a Full Camera region that starts where a layout region ends, during its lead-in:
+/// the layout region's layers gliding into camera 0 frame-filling (`full_cam0`), on the same
+/// window and curve as a layout region's lead-in. None anywhere else.
+fn full_camera_lead_in(
+    regions: &[SceneCameraLayoutRegion],
+    fullscreen: &[SceneCameraFullscreenRegion],
+    t: f32,
+    clock: &ScreenClock,
+    full_cam0: &[CameraLayerPlan],
+) -> Option<Vec<CameraLayerPlan>> {
+    let full = fullscreen.iter().find(|f| {
+        f.end_sec > f.start_sec && f.start_sec as f32 <= t && t <= f.end_sec as f32
+    })?;
+    let before = regions.iter().find(|r| {
+        r.end_sec > r.start_sec && (r.end_sec - full.start_sec).abs() <= ADJACENT_S
+    })?;
+    let (start, end) = (clock.at(full.start_sec as f32), clock.at(full.end_sec as f32));
+    let t = clock.at(t);
+    let win_in = TRANSITION_WINDOW_S.min((end - start) * 0.5);
+    if t - start >= win_in {
+        return None;
+    }
+    let from: Vec<CameraLayerPlan> = before.layers.iter().map(plan_of).collect();
+    Some(blend(&from, full_cam0, ease_out_screen_studio((t - start) / win_in)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::scene::SceneRect;
+
+    const PIP: [f32; 4] = [0.75, 0.7, 0.22, 0.22];
+    const CORNER: [f32; 4] = [0.05, 0.05, 0.2, 0.2];
+    const FULL: [f32; 4] = [0.0, 0.0, 1.0, 1.0];
+
+    fn default_pip() -> Option<CameraLayerPlan> {
+        Some(CameraLayerPlan {
+            camera: 0,
+            dst: PIP,
+            radius_frac: 0.5,
+            shape: 1,
+            opacity: 1.0,
+            fills_frame: false,
+        })
+    }
+
+    fn region(start: f64, end: f64, layers: &[(usize, [f32; 4], bool)]) -> SceneCameraLayoutRegion {
+        SceneCameraLayoutRegion {
+            clip_index: Some(0),
+            start_sec: start,
+            end_sec: end,
+            layers: layers
+                .iter()
+                .map(|&(camera, r, fills_frame)| SceneCameraLayer {
+                    camera,
+                    rect: SceneRect { x: r[0], y: r[1], width: r[2], height: r[3] },
+                    radius_frac: if fills_frame { 0.0 } else { 0.3 },
+                    shape: if fills_frame { "rectangle" } else { "rounded" }.to_string(),
+                    fills_frame,
+                })
+                .collect(),
+        }
+    }
+
+    fn at(regions: &[SceneCameraLayoutRegion], t: f32) -> Vec<CameraLayerPlan> {
+        camera_layers_at(regions, &[], t, &ScreenClock::default(), default_pip())
+    }
+
+    fn layer(layers: &[CameraLayerPlan], camera: usize) -> Option<CameraLayerPlan> {
+        layers.iter().copied().find(|l| l.camera == camera)
+    }
+
+    fn strictly_between(v: f32, a: f32, b: f32) -> bool {
+        v > a.min(b) && v < a.max(b)
+    }
+
+    #[test]
+    fn outside_every_region_only_the_default_camera_is_drawn() {
+        let regions = [region(2.0, 6.0, &[(1, FULL, true)])];
+        for t in [0.0, 1.9, 6.1, 9.0] {
+            assert_eq!(at(&regions, t), vec![default_pip().unwrap()], "t = {t}");
+        }
+        assert!(camera_layers_at(&regions, &[], 1.0, &ScreenClock::default(), None).is_empty());
+    }
+
+    #[test]
+    fn inside_a_region_after_the_lead_in_its_layers_are_drawn_fully() {
+        let regions = [region(2.0, 6.0, &[(1, FULL, true), (0, CORNER, false)])];
+        let layers = at(&regions, 4.0);
+        assert_eq!(layers.len(), 2);
+        assert_eq!(layers[0].camera, 1);
+        assert_eq!(layers[0].dst, FULL);
+        assert_eq!(layers[0].opacity, 1.0);
+        assert!(layers[0].fills_frame);
+        assert_eq!(layers[1].camera, 0);
+        assert_eq!(layers[1].dst, CORNER);
+        assert_eq!(layers[1].opacity, 1.0);
+        assert_eq!(layers[1].shape, webcam_shape_code("rounded"));
+        assert_eq!(layers[1].radius_frac, 0.3);
+    }
+
+    #[test]
+    fn entering_a_region_glides_camera_0_and_fades_in_a_new_camera() {
+        let regions = [region(2.0, 6.0, &[(1, FULL, true), (0, CORNER, false)])];
+        let layers = at(&regions, 2.0 + TRANSITION_WINDOW_S / 2.0);
+        let cam0 = layer(&layers, 0).expect("camera 0");
+        for i in 0..4 {
+            assert!(strictly_between(cam0.dst[i], PIP[i], CORNER[i]), "dst[{i}] = {}", cam0.dst[i]);
+        }
+        assert_eq!(cam0.opacity, 1.0);
+        let cam1 = layer(&layers, 1).expect("camera 1");
+        assert!(strictly_between(cam1.opacity, 0.0, 1.0), "opacity {}", cam1.opacity);
+        assert_eq!(cam1.dst, FULL);
+        // On the region's start the glide has not begun.
+        assert_eq!(at(&regions, 2.0), vec![default_pip().unwrap()]);
+    }
+
+    #[test]
+    fn leaving_a_region_returns_to_the_default() {
+        let regions = [region(2.0, 6.0, &[(1, FULL, true), (0, CORNER, false)])];
+        let win_out = FULLSCREEN_LEAD_OUT_WINDOW_S.min(2.0);
+        let layers = at(&regions, 6.0 - win_out / 2.0);
+        let cam0 = layer(&layers, 0).expect("camera 0");
+        for i in 0..4 {
+            assert!(strictly_between(cam0.dst[i], PIP[i], CORNER[i]), "dst[{i}] = {}", cam0.dst[i]);
+        }
+        let cam1 = layer(&layers, 1).expect("camera 1");
+        assert!(strictly_between(cam1.opacity, 0.0, 1.0), "opacity {}", cam1.opacity);
+        // On the region's end it is back to the default, exactly.
+        let end = at(&regions, 6.0);
+        assert_eq!(end.len(), 1);
+        assert_eq!(end[0].camera, 0);
+        for i in 0..4 {
+            assert!((end[0].dst[i] - PIP[i]).abs() < 1e-6);
+        }
+    }
+
+    #[test]
+    fn adjacent_regions_glide_directly() {
+        let regions = [region(2.0, 5.0, &[(1, FULL, true)]), region(5.0, 8.0, &[(2, FULL, true)])];
+        // The end of A keeps A: no lead-out to the default PiP.
+        let before = at(&regions, 5.0 - 0.01);
+        assert_eq!(before.len(), 1);
+        assert_eq!(before[0].camera, 1);
+        assert_eq!(before[0].opacity, 1.0);
+        // B's lead-in hands camera 1 over to camera 2.
+        let during = at(&regions, 5.0 + TRANSITION_WINDOW_S / 2.0);
+        let cam1 = layer(&during, 1).expect("camera 1 fading out");
+        let cam2 = layer(&during, 2).expect("camera 2 fading in");
+        assert!(strictly_between(cam1.opacity, 0.0, 1.0));
+        assert!(strictly_between(cam2.opacity, 0.0, 1.0));
+        // Neither region has camera 0, so the default PiP never shows around the seam.
+        let mut t = 4.8f32;
+        while t <= 5.2 {
+            assert!(layer(&at(&regions, t), 0).is_none(), "camera 0 at t = {t}");
+            t += 0.01;
+        }
+    }
+
+    fn full_camera(start: f64, end: f64) -> SceneCameraFullscreenRegion {
+        SceneCameraFullscreenRegion {
+            clip_index: Some(0),
+            start_sec: start,
+            end_sec: end,
+            rotation: 0,
+            mirror: None,
+            full_frame: false,
+        }
+    }
+
+    /// The plan with Full Camera regions, camera 0's default placed as `plan_frame` places it:
+    /// grown from the PiP to the frame by the Full Camera progress.
+    fn at_with_full(
+        regions: &[SceneCameraLayoutRegion],
+        fulls: &[SceneCameraFullscreenRegion],
+        t: f32,
+    ) -> Vec<CameraLayerPlan> {
+        let clock = ScreenClock::default();
+        let p = crate::regions::camera_fullscreen_progress_at(fulls, t, &clock, regions);
+        let default = CameraLayerPlan {
+            dst: std::array::from_fn(|i| lerp(PIP[i], FULL[i], p)),
+            fills_frame: p >= 1.0,
+            ..default_pip().unwrap()
+        };
+        camera_layers_at(regions, fulls, t, &clock, Some(default))
+    }
+
+    /// Camera 0 on the straight path between two rects: never the default PiP's geometry.
+    fn on_the_path(dst: [f32; 4], a: [f32; 4], b: [f32; 4]) -> bool {
+        (0..4).all(|i| dst[i] >= a[i].min(b[i]) - 1e-5 && dst[i] <= a[i].max(b[i]) + 1e-5)
+    }
+
+    #[test]
+    fn full_camera_then_layout_region_glides_directly() {
+        let regions = [region(5.0, 8.0, &[(1, FULL, true), (0, CORNER, false)])];
+        let fulls = [full_camera(2.0, 5.0)];
+        // The end of the Full Camera region keeps camera 0 on the frame: no shrink.
+        let before = at_with_full(&regions, &fulls, 5.0 - 0.01);
+        assert_eq!(before.len(), 1);
+        assert_eq!(before[0].camera, 0);
+        assert_eq!(before[0].dst, FULL);
+        assert!(before[0].fills_frame);
+        // The layout region's lead-in moves camera 0 from the frame to its corner.
+        let during = at_with_full(&regions, &fulls, 5.0 + TRANSITION_WINDOW_S / 2.0);
+        let cam0 = layer(&during, 0).expect("camera 0");
+        for i in 2..4 {
+            assert!(strictly_between(cam0.dst[i], FULL[i], CORNER[i]), "dst[{i}] = {}", cam0.dst[i]);
+        }
+        let cam1 = layer(&during, 1).expect("camera 1 fading in");
+        assert!(strictly_between(cam1.opacity, 0.0, 1.0));
+        // The default PiP never shows around the seam.
+        let mut t = 3.5f32;
+        while t <= 5.0 + TRANSITION_WINDOW_S + 0.1 {
+            let cam0 = layer(&at_with_full(&regions, &fulls, t), 0).expect("camera 0");
+            assert!(on_the_path(cam0.dst, FULL, CORNER), "t = {t}: {:?}", cam0.dst);
+            assert_eq!(cam0.opacity, 1.0, "t = {t}");
+            t += 0.005;
+        }
+    }
+
+    #[test]
+    fn layout_region_then_full_camera_glides_directly() {
+        let regions = [region(2.0, 5.0, &[(1, FULL, true), (0, CORNER, false)])];
+        let fulls = [full_camera(5.0, 8.0)];
+        // The end of the layout region keeps its layers: no lead-out to the default PiP.
+        let before = at_with_full(&regions, &fulls, 5.0 - 0.01);
+        assert_eq!(layer(&before, 0).expect("camera 0").dst, CORNER);
+        assert_eq!(layer(&before, 1).expect("camera 1").opacity, 1.0);
+        // The Full Camera lead-in takes camera 0 from its corner to the frame; camera 1 fades.
+        let during = at_with_full(&regions, &fulls, 5.0 + TRANSITION_WINDOW_S / 2.0);
+        let cam0 = layer(&during, 0).expect("camera 0");
+        for i in 2..4 {
+            assert!(strictly_between(cam0.dst[i], CORNER[i], FULL[i]), "dst[{i}] = {}", cam0.dst[i]);
+        }
+        let cam1 = layer(&during, 1).expect("camera 1 fading out");
+        assert!(strictly_between(cam1.opacity, 0.0, 1.0));
+        // After the lead-in camera 0 is the default again, which the held phase keeps full.
+        let after = at_with_full(&regions, &fulls, 5.0 + TRANSITION_WINDOW_S + 0.01);
+        assert_eq!(after.len(), 1);
+        assert_eq!(after[0].dst, FULL);
+        let mut t = 3.5f32;
+        while t <= 7.0 {
+            let cam0 = layer(&at_with_full(&regions, &fulls, t), 0).expect("camera 0");
+            assert!(on_the_path(cam0.dst, CORNER, FULL), "t = {t}: {:?}", cam0.dst);
+            assert_eq!(cam0.opacity, 1.0, "t = {t}");
+            t += 0.005;
+        }
+    }
+
+    #[test]
+    fn a_full_camera_region_off_the_seam_is_no_neighbour() {
+        // 10 ms apart: the layout region glides from the default as before.
+        let regions = [region(5.01, 8.0, &[(1, FULL, true), (0, CORNER, false)])];
+        let fulls = [full_camera(2.0, 5.0)];
+        assert_eq!(
+            at_with_full(&regions, &fulls, 5.01 + TRANSITION_WINDOW_S / 2.0),
+            at(&regions, 5.01 + TRANSITION_WINDOW_S / 2.0)
+        );
+        let shrinking = layer(&at_with_full(&regions, &fulls, 4.9), 0).expect("camera 0");
+        assert!(shrinking.dst[2] < 1.0, "the Full Camera region leads out: {:?}", shrinking.dst);
+    }
+
+    #[test]
+    fn a_short_region_halves_its_windows() {
+        let regions = [region(2.0, 3.0, &[(1, FULL, true)])];
+        // Both windows are 0.5 s: the middle is the only frame at full strength.
+        let mid = at(&regions, 2.5);
+        assert_eq!(mid.len(), 1);
+        assert_eq!(mid[0].camera, 1);
+        assert_eq!(mid[0].opacity, 1.0);
+        for t in [2.25, 2.75] {
+            let cam1 = layer(&at(&regions, t), 1).expect("camera 1");
+            assert!(strictly_between(cam1.opacity, 0.0, 1.0), "t = {t}");
+        }
+    }
+
+    #[test]
+    fn an_empty_region_draws_nothing_of_its_own() {
+        // start == end (and a reversed region) would otherwise match `t` at its one instant
+        // and draw its layers at full strength for that sample.
+        for regions in [
+            [region(3.0, 3.0, &[(1, FULL, true)])],
+            [region(3.0, 2.0, &[(1, FULL, true)])],
+        ] {
+            for t in [2.0, 2.5, 3.0] {
+                let layers = at(&regions, t);
+                assert!(layer(&layers, 1).is_none(), "t = {t}");
+                assert_eq!(layers.len(), 1, "t = {t}");
+                assert_eq!(layers[0].camera, 0, "t = {t}");
+            }
+        }
+        // Nor does it count as a neighbour: the region before it still leads out.
+        let regions = [region(2.0, 6.0, &[(1, FULL, true)]), region(6.0, 6.0, &[(1, FULL, true)])];
+        let cam1 = layer(&at(&regions, 5.9), 1).expect("camera 1");
+        assert!(strictly_between(cam1.opacity, 0.0, 1.0));
+    }
+
+    #[test]
+    fn fills_frame_layers_are_drawn_first() {
+        let regions = [region(2.0, 6.0, &[(0, CORNER, false), (1, FULL, true)])];
+        let order: Vec<usize> = at(&regions, 4.0).iter().map(|l| l.camera).collect();
+        assert_eq!(order, vec![1, 0]);
+        // During the lead-in too.
+        let order: Vec<usize> =
+            at(&regions, 2.0 + TRANSITION_WINDOW_S / 2.0).iter().map(|l| l.camera).collect();
+        assert_eq!(order, vec![1, 0]);
+    }
+}
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs
index c2b8bc17b..e9505224c 100644
--- a/crates/compositor/src/compositor_linux.rs
+++ b/crates/compositor/src/compositor_linux.rs
@@ -67,12 +67,12 @@ fn layer_source(models: bool) -> String {
 /// en parcourant les 18 wallpapers livres) en laissant le jeu actif resident.
 const IMG_CACHE_BUDGET_BYTES: u64 = 512 * 1024 * 1024;
 
-/// Taille du buffer uniforme d'un calque : `LayerCB` entier (192 octets), le `struct Layer` de
+/// Taille du buffer uniforme d'un calque : `LayerCB` entier (256 octets), le `struct Layer` de
 /// `layer.wgsl`. `blur.wgsl` n'en lit que les 128 premiers.
 const LAYER_BYTES: u64 = std::mem::size_of::<LayerCB>() as u64;
 
 /// `&LayerCB` -> ses octets. `LayerCB` est `#[repr(C, align(16))]`, son layout EST le buffer
-/// uniforme WGSL (douze vec4 = 192 octets).
+/// uniforme WGSL (seize vec4 = 256 octets).
 fn layer_bytes(cb: &LayerCB) -> &[u8] {
     unsafe { std::slice::from_raw_parts(cb as *const LayerCB as *const u8, LAYER_BYTES as usize) }
 }
@@ -349,6 +349,9 @@ pub struct Compositor {
     readback_yuv: RefCell<ReadbackRing>,
 
     // Etat pilote par live.rs (interior mutability : les methodes sont `&self`).
+    /// The frames of cameras 1..=3 (`set_extra_camera_frames`), as addresses (0 = none) so
+    /// the compositor's auto traits stay what they were without the raw pointers.
+    extra_camera_frames: std::cell::Cell<[usize; crate::camera_layers::MAX_EXTRA_CAMERAS]>,
     live_params: RefCell<LiveParams>,
     scene: RefCell<Option<Scene>>,
     cursor: RefCell<Option<crate::cursor::CursorTrack>>,
@@ -745,6 +748,7 @@ impl Compositor {
             readback,
             yuv: RefCell::new(None),
             readback_yuv,
+            extra_camera_frames: std::cell::Cell::new([0; crate::camera_layers::MAX_EXTRA_CAMERAS]),
             live_params: RefCell::new(LiveParams::default()),
             scene: RefCell::new(None),
             cursor: RefCell::new(None),
@@ -1166,6 +1170,9 @@ impl Compositor {
 
     pub fn set_scene(&self, s: Option<Scene>) {
         *self.scene.borrow_mut() = s;
+        // A new scene can drop the regions that drew an extra camera: forget its frames so a
+        // stale pointer is never drawn before the next `set_extra_camera_frames`.
+        self.extra_camera_frames.set([0; crate::camera_layers::MAX_EXTRA_CAMERAS]);
     }
 
     pub fn set_cursor(&self, track: crate::cursor::CursorTrack) {
@@ -1200,8 +1207,29 @@ impl Compositor {
     }
 
     /// Pas de cache de SRV cote wgpu (les `TextureView`s sont recreees a chaque
-    /// draw depuis le carrier) -- no-op conserve pour la symetrie d'API.
-    pub fn clear_srv_cache(&self) {}
+    /// draw depuis le carrier). Only the extra cameras' frame slots are reset.
+    pub fn clear_srv_cache(&self) {
+        // The extra cameras' frames belong to the decoders just closed: forget them too, so
+        // a stale pointer is never read before the next `set_extra_camera_frames`.
+        self.extra_camera_frames.set([0; crate::camera_layers::MAX_EXTRA_CAMERAS]);
+    }
+
+    /// Frames for cameras 1..=3 (index 0 = scene camera 1). A null or missing entry means that
+    /// camera is not drawn this frame. The compositor keeps the pointers and reads them in every
+    /// `compose_frame` until the next call, so they must stay valid until then.
+    pub unsafe fn set_extra_camera_frames(&self, frames: &[*const AVFrame]) {
+        let mut slots = [0usize; crate::camera_layers::MAX_EXTRA_CAMERAS];
+        for (slot, frame) in slots.iter_mut().zip(frames) {
+            *slot = *frame as usize;
+        }
+        self.extra_camera_frames.set(slots);
+    }
+
+    /// The frame set for scene camera `camera` (1..=3), null when there is none.
+    fn extra_camera_frame(&self, camera: usize) -> *const AVFrame {
+        let slots = self.extra_camera_frames.get();
+        camera.checked_sub(1).and_then(|k| slots.get(k).copied()).unwrap_or(0) as *const AVFrame
+    }
 
     // -- seam frame (lit le carrier `data[0]`) --
 
@@ -1568,7 +1596,8 @@ impl Compositor {
     /// son propre repli, et un echec silencieux redonnerait le noir qu'on corrige.
     ///
     /// `motion` anime l'image au temps programme `programme_t` ; la bulle webcam
-    /// passe `WallpaperMotion::None`.
+    /// passe `WallpaperMotion::None`. `transparency` = `layer_fx.x` (0 = opaque): a camera
+    /// layer's background box fades with the layer.
     #[allow(clippy::too_many_arguments)]
     fn image_bg_draw(
         &self,
@@ -1579,6 +1608,7 @@ impl Compositor {
         aspect: f32,
         motion: WallpaperMotion,
         programme_t: f32,
+        transparency: f32,
         dummy: &wgpu::TextureView,
     ) -> Result<BgDraw> {
         let (tex, iw, ih) = self.cached_image(path)?;
@@ -1600,6 +1630,7 @@ impl Compositor {
             mode: 6.0,
             fx: [0.0, 0.0, anim[0], anim[1]],
             mb,
+            layer_fx: [transparency, 0.0, 0.0, 0.0],
             ..Default::default()
         };
         let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
@@ -1620,15 +1651,19 @@ impl Compositor {
     ///
     /// `quad_px` / `radius_px` sont ceux de la bulle : le fond doit epouser ses
     /// coins arrondis, sinon un rectangle deborde derriere la camera.
+    ///
+    /// `transparency` = the camera layer's `layer_fx.x`: the box fades with the camera.
     fn webcam_bg_draw(
         &self,
         bg: Option<&SceneBackground>,
         dst: [f32; 4],
         quad_px: [f32; 2],
         radius_px: f32,
+        transparency: f32,
         dummy: &wgpu::TextureView,
     ) -> BgDraw {
         const BLACK: [f32; 4] = [0.0, 0.0, 0.0, 1.0];
+        let layer_fx = [transparency, 0.0, 0.0, 0.0];
         let flat = |cb: LayerCB| BgDraw { layer: self.make_bind(&cb, None, dummy), _tex: None, _view: None };
         let solid = |color: [f32; 4]| LayerCB {
             dst,
@@ -1636,6 +1671,7 @@ impl Compositor {
             radius_px,
             mode: 1.0,
             color,
+            layer_fx,
             ..Default::default()
         };
         match bg {
@@ -1653,6 +1689,7 @@ impl Compositor {
                     quad_px,
                     radius_px,
                     fx: [a.sin(), -a.cos(), 0.0, 0.0],
+                    layer_fx,
                     ..crate::frame_geometry::gradient_layer(stops, offsets, BLACK)
                 })
             }
@@ -1661,7 +1698,10 @@ impl Compositor {
                 // elle que l'image doit remplir sans etirement.
                 let aspect = if quad_px[1] > 0.0 { quad_px[0] / quad_px[1] } else { 1.0 };
                 let still = WallpaperMotion::None;
-                match self.image_bg_draw(path, dst, quad_px, radius_px, aspect, still, 0.0, dummy) {
+                let drawn = self.image_bg_draw(
+                    path, dst, quad_px, radius_px, aspect, still, 0.0, transparency, dummy,
+                );
+                match drawn {
                     Ok(d) => d,
                     Err(e) => {
                         // Meme contrat que le fond d'ecran : un chemin casse est
@@ -2397,7 +2437,10 @@ impl Compositor {
             BgLayer::Image(path, motion) => {
                 let full = [0.0, 0.0, 1.0, 1.0];
                 let t = g.programme_t;
-                match self.image_bg_draw(&path, full, [0.0, 0.0], 0.0, rw / rh, motion, t, &dummy) {
+                let drawn = self.image_bg_draw(
+                    &path, full, [0.0, 0.0], 0.0, rw / rh, motion, t, 0.0, &dummy,
+                );
+                match drawn {
                     Ok(d) => Some(d),
                     Err(e) => {
                         eprintln!("[fond image] \"{path}\" : {e:#}");
@@ -2429,7 +2472,10 @@ impl Compositor {
         // lancement gracieux, le temps que l'inference rende son premier masque.
         //
         // Calcule ICI, avant le draw comme avant l'ombre : les deux en dependent.
-        let (effect_code, blur_intensity, webcam_bg) = {
+        // Without layout regions camera 0 is drawn from `w_dst` (`webcam_bg`, `webcam_draw`,
+        // `webcam_shadow` below); with them every planned layer is (`camera_layer_draws`).
+        let unplanned = g.camera_layers.is_empty();
+        let (effect_code, blur_intensity, custom_bg) = {
             let has_mask = self.webcam_mask.borrow().is_some();
             let effect = scene_ref
                 .as_ref()
@@ -2445,24 +2491,16 @@ impl Compositor {
                 // fond. Le shader ne sait peindre qu'une couleur plate sous le
                 // masque ; degrades et images y tombaient sur du noir, et le defaut
                 // EST une image.
-                Some((code, e)) if code > 2.5 => {
-                    // Sans piste webcam le fond peindrait un rectangle seul dans le
-                    // cadre : il ne se prepare que si la camera se dessine.
-                    let bg = webcam_planes.is_some().then(|| {
-                        self.webcam_bg_draw(
-                            e.background.as_ref(),
-                            g.w_dst,
-                            g.w_px,
-                            g.w_radius,
-                            &dummy,
-                        )
-                    });
-                    (1.0, 0.0, bg)
-                }
+                Some((code, e)) if code > 2.5 => (1.0, 0.0, Some(e.background.as_ref())),
                 Some((code, e)) => (code, e.blur_intensity.clamp(0.0, 1.0), None),
                 None => (0.0, 0.0, None),
             }
         };
+        // Sans piste webcam le fond peindrait un rectangle seul dans le cadre : il ne se
+        // prepare que si la camera se dessine.
+        let webcam_bg = custom_bg
+            .filter(|_| unplanned && webcam_planes.is_some())
+            .map(|bg| self.webcam_bg_draw(bg, g.w_dst, g.w_px, g.w_radius, 0.0, &dummy));
         // L'ombre se juge sur le mode DE LA SCENE, pas sur `effect_code` : le fond
         // personnalise se compose desormais en detourage (code 1) tout en gardant
         // sa bulle, et tester le code compose la lui retirerait. Meme lecture que
@@ -2471,7 +2509,10 @@ impl Compositor {
             scene_ref.as_ref().and_then(|s| s.webcam_effect.as_ref()),
             Some(e) if e.shader_code() == 1.0
         ) && self.webcam_mask.borrow().is_some();
-        let webcam_draw = webcam_planes.as_ref().map(|(wy, wu, wv)| {
+        // Camera 0's crop, mirror and desk turn as camera settings, plus its homography
+        // (`Scene::camera(0)`): with one, `src` is not read and the crop is dropped.
+        let cam0 = g.camera0_settings(scene_ref.as_ref());
+        let webcam_draw = webcam_planes.as_ref().filter(|_| unplanned).map(|(wy, wu, wv)| {
             // COVER-CROP. `src` etait cable a [0,0,1,1], donc la texture entiere
             // etait etiree sur la boite quelle que soit sa forme : le facteur de
             // deformation valait exactement `box_ar / cam_ar`. Invisible en PiP
@@ -2481,45 +2522,27 @@ impl Compositor {
             //
             // `cover_crop_uv` est la primitive partagee que macOS et Windows
             // utilisent ; elle rend le rect inchange quand il a deja le bon
-            // ratio, donc aucun placement correct ne bouge.
-            let [cu0, cv0, cu1, cv1] = crate::frame_geometry::webcam_source_rect(
+            // ratio, donc aucun placement correct ne bouge. Mirror and the desk-shot
+            // turn are both bound swaps: u for horizontal, v for vertical.
+            let src = crate::frame_geometry::camera_source_rect(
+                Some(&cam0),
                 [wcw, wch],
                 [wtw as f32, wth as f32],
-                if g.webcam.full_frame {
-                    None
-                } else {
-                    scene_ref.as_ref().and_then(|scene| scene.layout.webcam_crop)
-                },
                 g.w_px[0] / g.w_px[1].max(0.0001),
             );
-            // Mirror and the desk-shot turn are both bound swaps: u for horizontal, v for vertical.
-            let (u0, u1) = if g.webcam.flip_u { (cu1, cu0) } else { (cu0, cu1) };
-            let (v0, v1) = if g.webcam.flip_v { (cv1, cv0) } else { (cv0, cv1) };
             // `src_prev` doit valoir EXACTEMENT le `src` de ce draw, miroir
             // compris : le shader s'en sert pour reconstruire l'UV de la frame
             // precedente, et un rect source qui ne correspond pas au calque
             // dessine ferait diverger la trainee vers une zone de la texture qui
             // n'a jamais ete affichee. Seul `dst_prev` porte le mouvement.
-            let cb = LayerCB {
-                dst: g.w_dst,
-                src: [u0, v0, u1, v1],
-                quad_px: g.w_px,
-                radius_px: g.w_radius,
-                mode: 0.0,
-                // `color.a` porte l'alpha du decoupage (`color.a * personne`) ; le
-                // RGB n'est plus lu, le fond ayant deja ete peint sous la camera.
-                color: [0.0, 0.0, 0.0, 1.0],
-                // `fx.xy` = etendue valide de la texture webcam, par quoi le
-                // shader divise `uv` pour retomber dans l'espace du masque ;
-                // `fx.z` = mode, `fx.w` = intensite du flou. Contrat commun aux
-                // trois back-ends, cf. `layer.wgsl` et `webcam-segmentation.md`.
-                fx: [w_valid[0], w_valid[1], effect_code, blur_intensity],
-                src_prev: [u0, v0, u1, v1],
-                dst_prev: g.w_dst_prev,
-                mb: [g.mb_taps, g.mb_amount, 1.0, 0.0],
-                cover: [g.webcam_cover, 0.04 * g.w_px[0].min(g.w_px[1]) * g.webcam_cover, 0.35, 0.0],
-                ..Default::default()
-            };
+            // `fx.xy` = etendue valide de la texture webcam, par quoi le
+            // shader divise `uv` pour retomber dans l'espace du masque ;
+            // `fx.z` = mode, `fx.w` = intensite du flou. Contrat commun aux
+            // trois back-ends, cf. `layer.wgsl` et `webcam-segmentation.md`.
+            let cb = crate::frame_geometry::with_camera_homography(
+                g.webcam_video_cb(src, w_valid, effect_code, blur_intensity),
+                Some(&cam0),
+            );
             // Le masque est lie par `make_bind` sur tous les draws, pas seulement
             // celui-ci : le layout l'exige (cf. `tex_entry(4)`).
             self.make_bind(&cb, Some((wy, wu, wv)), &dummy)
@@ -2553,6 +2576,71 @@ impl Compositor {
             self.make_bind(&cb, None, &dummy)
         });
 
+        // Every planned camera layer, in order, each as shadow, then (camera 0) the custom
+        // background, then the video: one uniform buffer and bind group per draw, drawn in
+        // the "webcam-pass" below. Camera 0 keeps its frame, effects and mask; the extra
+        // cameras draw from `set_extra_camera_frames` without effects, and a camera without a
+        // frame is skipped. `extra_planes` keeps their views alive until the pass is encoded.
+        let mut camera_layer_draws: Vec<BgDraw> = Vec::new();
+        let mut extra_planes = Vec::new();
+        let render = [rw, rh];
+        let cam0_base = g.webcam_video_cb([0.0; 4], w_valid, effect_code, blur_intensity);
+        let plain = |layer: LayerBind| BgDraw { layer, _tex: None, _view: None };
+        for plan in &g.camera_layers {
+            if plan.camera == 0 {
+                // `webcam_planes` is already gated on `lp.has_webcam`.
+                let Some((wy, wu, wv)) = webcam_planes.as_ref() else { continue };
+                let video = crate::frame_geometry::camera_layer_cb(
+                    plan,
+                    Some(&cam0),
+                    [wcw, wch],
+                    [wtw as f32, wth as f32],
+                    render,
+                    &cam0_base,
+                );
+                if let Some(shadow) =
+                    g.camera_layer_shadow(plan, &video, render, cfg.shadow, is_cutout)
+                {
+                    camera_layer_draws.push(plain(self.make_bind(&shadow, None, &dummy)));
+                }
+                if let Some(bg) = custom_bg {
+                    let (dst, quad_px, radius_px) = (video.dst, video.quad_px, video.radius_px);
+                    let t = video.layer_fx[0];
+                    let bg = self.webcam_bg_draw(bg, dst, quad_px, radius_px, t, &dummy);
+                    camera_layer_draws.push(bg);
+                }
+                let bind = self.make_bind(&video, Some((wy, wu, wv)), &dummy);
+                camera_layer_draws.push(plain(bind));
+            } else {
+                let frame = self.extra_camera_frame(plan.camera);
+                if Self::pixel_buffer_of(frame).is_none() {
+                    continue;
+                }
+                let Ok(planes) = self.nv12_srvs(frame) else { continue };
+                let (tw, th) = self.tex_dims(frame);
+                let visible = [(*frame).width as f32, (*frame).height as f32];
+                let tex = [tw as f32, th as f32];
+                let valid = [visible[0] / tex[0].max(1.0), visible[1] / tex[1].max(1.0)];
+                let video = crate::frame_geometry::camera_layer_cb(
+                    plan,
+                    scene_ref.as_ref().and_then(|s| s.camera(plan.camera)),
+                    visible,
+                    tex,
+                    render,
+                    &crate::frame_geometry::extra_camera_base_cb(valid),
+                );
+                if let Some(shadow) =
+                    g.camera_layer_shadow(plan, &video, render, cfg.shadow, false)
+                {
+                    camera_layer_draws.push(plain(self.make_bind(&shadow, None, &dummy)));
+                }
+                let (ey, eu, ev) = &planes;
+                let bind = self.make_bind(&video, Some((ey, eu, ev)), &dummy);
+                camera_layer_draws.push(plain(bind));
+                extra_planes.push(planes);
+            }
+        }
+
         // ANNOTATIONS -- calque le plus haut, place relativement au rect ecran
         // (les coords x/y/w/h de l'annotation sont des fractions de ce rect, cf.
         // `scene.rs`). Le rect est `g.s_ann`, l'ecran SANS ZOOM, et surtout pas
@@ -3417,6 +3505,9 @@ impl Compositor {
             if let Some(layer) = &webcam_draw {
                 self.draw_layer(&mut rpass, layer, false);
             }
+            for draw in &camera_layer_draws {
+                self.draw_layer(&mut rpass, &draw.layer, false);
+            }
         }
         // Passe 3 : les autres annotations, par-dessus tout le reste (les flous sont passes avant
         // le curseur). Elle existe meme sans annotation : deux passes consecutives sur la MEME
@@ -4776,12 +4867,37 @@ mod tests {
 
     /// `compose_pip` sur une scene deja construite, pour les tests qui la retouchent.
     fn compose_pip_scene(comp: &Compositor, gpu: &Gpu, scene: Scene, shadow: bool) -> Vec<u8> {
+        let screen = FakeFrame::new(gpu, 128, 128, |_, _| 126);
+        let webcam = FakeFrame::new(gpu, 64, 64, |_, _| Y_WHITE);
+        compose_pip_frames(comp, scene, shadow, &screen, &webcam)
+    }
+
+    /// `compose_pip_scene` with the caller's own screen and camera frames.
+    fn compose_pip_frames(
+        comp: &Compositor,
+        scene: Scene,
+        shadow: bool,
+        screen: &FakeFrame,
+        webcam: &FakeFrame,
+    ) -> Vec<u8> {
+        compose_pip_frames_with_extras(comp, scene, shadow, screen, webcam, &[])
+    }
+
+    /// `compose_pip_frames` with extra camera frames. They are handed over AFTER `set_scene`,
+    /// which forgets the previous ones, and before the compose, as the product code does.
+    fn compose_pip_frames_with_extras(
+        comp: &Compositor,
+        scene: Scene,
+        shadow: bool,
+        screen: &FakeFrame,
+        webcam: &FakeFrame,
+        extra: &[*const AVFrame],
+    ) -> Vec<u8> {
         comp.set_live_params(live_params_from_scene(&scene));
         comp.set_has_webcam(true);
         comp.set_scene(Some(scene));
+        unsafe { comp.set_extra_camera_frames(extra) };
 
-        let screen = FakeFrame::new(gpu, 128, 128, |_, _| 126);
-        let webcam = FakeFrame::new(gpu, 64, 64, |_, _| Y_WHITE);
         let mut cfg = Cfg::c8();
         cfg.bg_blur = 0.0;
         cfg.zoom = false;
@@ -4910,6 +5026,241 @@ mod tests {
         );
     }
 
+    /// `pip_scene_json` on a black background: with a black screen too, the camera is drawn over
+    /// black wherever it lands, so its colour can be read without knowing where the PiP is.
+    fn black_pip_scene() -> Scene {
+        let json = pip_scene_json(NO_EFFECT).replace("#0080ff", "#000000");
+        Scene::from_json(&json).expect("scene json")
+    }
+
+    /// The x of every pixel of a `width`-wide RGBA image that `pred` accepts.
+    fn xs_where(rgba: &[u8], width: usize, pred: impl Fn(&[u8]) -> bool) -> Vec<usize> {
+        rgba.chunks_exact(4)
+            .enumerate()
+            .filter(|(_, px)| pred(px))
+            .map(|(i, _)| i % width)
+            .collect()
+    }
+
+    /// The RGBA of pixel (x, y) of a 320-wide readback.
+    fn pixel_at(rgba: &[u8], x: usize, y: usize) -> [u8; 4] {
+        let i = (y * 320 + x) * 4;
+        [rgba[i], rgba[i + 1], rgba[i + 2], rgba[i + 3]]
+    }
+
+    /// A 64x64 camera frame of one RGB colour (BT.709 limited, `rgb_to_nv12`).
+    fn solid_camera(gpu: &Gpu, rgb: [u8; 3]) -> FakeFrame {
+        let (w, h) = (64u32, 64u32);
+        let pixels: Vec<u8> = (0..w * h).flat_map(|_| rgb).collect();
+        let (y, uv) = rgb_to_nv12(&pixels, w, h);
+        FakeFrame::from_planes(gpu, w, h, &y, &uv)
+    }
+
+    /// Camera 1 over the whole frame, and camera 0 as a PiP in the bottom-right corner
+    /// (x 224..304, y 126..171 of a 320x180 frame).
+    const CAMERA_1_FULL: &str = r#"{"camera":1,"rect":{"x":0,"y":0,"width":1,"height":1},"shape":"rectangle","fillsFrame":true}"#;
+    const CAMERA_0_PIP: &str = r#"{"camera":0,"rect":{"x":0.7,"y":0.7,"width":0.25,"height":0.25},"shape":"rectangle"}"#;
+
+    /// A camera layout region from 2 s to 8 s with these layers (JSON objects, comma-separated).
+    fn layout_region(layers: &str) -> crate::scene::SceneCameraLayoutRegion {
+        serde_json::from_str(&format!(r#"{{"startSec":2.0,"endSec":8.0,"layers":[{layers}]}}"#))
+            .expect("region json")
+    }
+
+    /// The time in the lead-in of `layout_region` where a layer only the region shows is drawn
+    /// at opacity 0.5 (and one only the default shows, at 0.5 too). Checked against the plan.
+    fn half_way_in(region: &crate::scene::SceneCameraLayoutRegion) -> f32 {
+        let (mut lo, mut hi) = (0.0f32, 1.0f32);
+        for _ in 0..40 {
+            let mid = 0.5 * (lo + hi);
+            if crate::regions::ease_out_screen_studio(mid) < 0.5 {
+                lo = mid;
+            } else {
+                hi = mid;
+            }
+        }
+        let t = 2.0 + lo * crate::regions::TRANSITION_WINDOW_S;
+        let default_cam0 = crate::camera_layers::CameraLayerPlan {
+            camera: 0,
+            dst: [0.7, 0.7, 0.25, 0.25],
+            radius_frac: 0.0,
+            shape: 0,
+            opacity: 1.0,
+            fills_frame: false,
+        };
+        let clock = crate::regions::ScreenClock::new(&[], 0);
+        let layers = crate::camera_layers::camera_layers_at(
+            std::slice::from_ref(region),
+            &[],
+            t,
+            &clock,
+            Some(default_cam0),
+        );
+        assert!(
+            layers.iter().any(|l| (l.opacity - 0.5).abs() < 1e-3),
+            "no layer at half opacity at {t}: {layers:?}"
+        );
+        t
+    }
+
+    /// `compose_pip_frames` at source time `t`, with these extra camera frames set (and cleared
+    /// again afterwards).
+    fn compose_layers(
+        comp: &Compositor,
+        scene: Scene,
+        t: f32,
+        screen: &FakeFrame,
+        camera_0: &FakeFrame,
+        extra: &[*const AVFrame],
+    ) -> Vec<u8> {
+        comp.set_timeline_time(Some(t));
+        let rgba = compose_pip_frames_with_extras(comp, scene, false, screen, camera_0, extra);
+        unsafe { comp.set_extra_camera_frames(&[]) };
+        rgba
+    }
+
+    fn is_green(px: [u8; 4]) -> bool {
+        px[1] > 200 && px[0] < 60 && px[2] < 60
+    }
+
+    /// A `camera-full-pip` region: camera 1 (green) fills the frame, camera 0 (white) is the PiP
+    /// over it. The centre shows camera 1, the PiP rect camera 0.
+    #[test]
+    fn two_cameras_draw_in_their_planned_rects() {
+        let Some(gpu) = gpu() else { return };
+        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
+        let screen = FakeFrame::new(&gpu, 128, 128, |_, _| Y_BLACK);
+        let white = FakeFrame::new(&gpu, 64, 64, |_, _| Y_WHITE);
+        let green = solid_camera(&gpu, [0, 255, 0]);
+        let mut scene = black_pip_scene();
+        scene.camera_layout_regions.push(layout_region(&format!("{CAMERA_1_FULL},{CAMERA_0_PIP}")));
+        // 5 s: past the lead-in, before the lead-out.
+        let rgba = compose_layers(&comp, scene, 5.0, &screen, &white, &[green.as_ptr()]);
+        let centre = pixel_at(&rgba, 160, 90);
+        assert!(is_green(centre), "the centre is not camera 1: {centre:?}");
+        let pip = pixel_at(&rgba, 264, 148);
+        assert!(pip[..3].iter().all(|&c| c > 240), "the PiP rect is not camera 0: {pip:?}");
+        let corner = pixel_at(&rgba, 10, 10);
+        assert!(is_green(corner), "camera 1 does not fill the frame: {corner:?}");
+    }
+
+    /// Without a frame for camera 1 its layer is skipped, empty slice or null pointer alike:
+    /// the centre shows the screen, as it does without any region.
+    #[test]
+    fn a_missing_extra_camera_skips_its_layer() {
+        let Some(gpu) = gpu() else { return };
+        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
+        let screen = FakeFrame::new(&gpu, 128, 128, |_, _| 126);
+        let white = FakeFrame::new(&gpu, 64, 64, |_, _| Y_WHITE);
+        let control = compose_layers(&comp, black_pip_scene(), 5.0, &screen, &white, &[]);
+        let screen_px = pixel_at(&control, 160, 90);
+        assert!(screen_px[1] > 100 && screen_px[1] < 160, "control: the centre is not the screen");
+
+        let mut scene = black_pip_scene();
+        scene.camera_layout_regions.push(layout_region(&format!("{CAMERA_1_FULL},{CAMERA_0_PIP}")));
+        for extra in [&[][..], &[std::ptr::null()][..]] {
+            let rgba = compose_layers(&comp, scene.clone(), 5.0, &screen, &white, extra);
+            assert_eq!(pixel_at(&rgba, 160, 90), screen_px, "{} frames set", extra.len());
+            let pip = pixel_at(&rgba, 264, 148);
+            assert!(pip[..3].iter().all(|&c| c > 240), "camera 0 is no longer drawn: {pip:?}");
+        }
+    }
+
+    /// Half-way into the lead-in camera 1 fades in at opacity 0.5: over the black screen the
+    /// centre is half as green as in the hold.
+    #[test]
+    fn a_fading_extra_camera_is_half_transparent() {
+        let Some(gpu) = gpu() else { return };
+        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
+        let screen = FakeFrame::new(&gpu, 128, 128, |_, _| Y_BLACK);
+        let white = FakeFrame::new(&gpu, 64, 64, |_, _| Y_WHITE);
+        let green = solid_camera(&gpu, [0, 255, 0]);
+        let region = layout_region(&format!("{CAMERA_1_FULL},{CAMERA_0_PIP}"));
+        let t = half_way_in(&region);
+        let mut scene = black_pip_scene();
+        scene.camera_layout_regions.push(region);
+
+        let hold = compose_layers(&comp, scene.clone(), 5.0, &screen, &white, &[green.as_ptr()]);
+        let full = pixel_at(&hold, 160, 90);
+        assert!(is_green(full), "control: the centre is not camera 1 in the hold: {full:?}");
+        let half = compose_layers(&comp, scene, t, &screen, &white, &[green.as_ptr()]);
+        let px = pixel_at(&half, 160, 90);
+        let expected = full[1] as i32 / 2;
+        assert!(
+            (px[1] as i32 - expected).abs() <= 8 && px[0] < 30 && px[2] < 30,
+            "half-way in: {px:?}, expected green near {expected}"
+        );
+    }
+
+    /// Camera 0 fading out at opacity 0.5 (a region that shows only camera 1, which has no
+    /// frame) draws the (white) camera at half strength over the (black) screen: every camera
+    /// pixel is mid grey, none of them is white any more.
+    #[test]
+    fn transparency_half_halves_the_camera_over_the_screen() {
+        let Some(gpu) = gpu() else { return };
+        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
+        let screen = FakeFrame::new(&gpu, 128, 128, |_, _| Y_BLACK);
+        let webcam = FakeFrame::new(&gpu, 64, 64, |_, _| Y_WHITE);
+        let opaque = compose_pip_frames(&comp, black_pip_scene(), false, &screen, &webcam);
+        let whole = camera_pixels(&opaque);
+        assert!(whole > 200, "the camera is not on screen, the test proves nothing");
+
+        let region = layout_region(CAMERA_1_FULL);
+        let t = half_way_in(&region);
+        let mut scene = black_pip_scene();
+        scene.camera_layout_regions.push(region);
+        let half = compose_layers(&comp, scene, t, &screen, &webcam, &[]);
+        assert_eq!(camera_pixels(&half), 0, "a half transparent camera still has white pixels");
+        let grey = half
+            .chunks_exact(4)
+            .filter(|px| px[..3].iter().all(|&c| (126..=130).contains(&c)))
+            .count();
+        assert!(
+            grey as f32 >= whole as f32 * 0.9,
+            "{grey} mid-grey pixels for {whole} camera pixels drawn opaque"
+        );
+    }
+
+    /// Camera 0's perspective applies without any layout region. A homography that flips the
+    /// camera horizontally draws its right half on the left of the layer: a camera red on the
+    /// left and blue on the right shows blue left of red. The control (no perspective) shows it
+    /// the other way round, so the flip is the homography's doing.
+    #[test]
+    fn camera_0_perspective_applies_without_layout_regions() {
+        let Some(gpu) = gpu() else { return };
+        let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized");
+        let screen = FakeFrame::new(&gpu, 128, 128, |_, _| Y_BLACK);
+        // BT.709 limited: red = (Y 63, Cb 102, Cr 240), blue = (Y 32, Cb 240, Cr 118).
+        let (w, h) = (64u32, 64u32);
+        let y: Vec<u8> = (0..w * h).map(|i| if i % w < w / 2 { 63 } else { 32 }).collect();
+        let uv: Vec<u8> = (0..h / 2)
+            .flat_map(|_| (0..w / 2).flat_map(|j| if j < w / 4 { [102, 240] } else { [240, 118] }))
+            .collect();
+        let webcam = FakeFrame::from_planes(&gpu, w, h, &y, &uv);
+        let red = |px: &[u8]| px[0] > 200 && px[1] < 60 && px[2] < 60;
+        let blue = |px: &[u8]| px[2] > 200 && px[0] < 60 && px[1] < 60;
+
+        let plain = compose_pip_frames(&comp, black_pip_scene(), false, &screen, &webcam);
+        let (r, b) = (xs_where(&plain, 320, red), xs_where(&plain, 320, blue));
+        assert!(r.len() > 50 && b.len() > 50, "control: {} red, {} blue pixels", r.len(), b.len());
+        assert!(r.iter().max() < b.iter().min(), "control: the camera's red half is on the left");
+
+        let mut scene = black_pip_scene();
+        assert!(scene.camera_layout_regions.is_empty());
+        scene.cameras.push(crate::scene::SceneCamera {
+            index: 0,
+            rotation: 0,
+            mirror: None,
+            crop: None,
+            homography: Some([-1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0]),
+            aspect: None,
+        });
+        let flipped = compose_pip_frames(&comp, scene, false, &screen, &webcam);
+        let (r, b) = (xs_where(&flipped, 320, red), xs_where(&flipped, 320, blue));
+        assert!(r.len() > 50 && b.len() > 50, "flipped: {} red, {} blue pixels", r.len(), b.len());
+        assert!(b.iter().max() < r.iter().min(), "flipped: the left half of the layer is blue");
+    }
+
     /// Le tour complet, celui qui a besoin d'ONNX Runtime : capture -> inference
     /// -> masque -> composite, entraine par `compose_frame` seul. Se saute
     /// proprement sans la bibliotheque, ce que fait la CI — cf.
diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rs
index 493504be3..a9a571e98 100644
--- a/crates/compositor/src/compositor_macos.rs
+++ b/crates/compositor/src/compositor_macos.rs
@@ -266,6 +266,9 @@ pub struct Compositor {
     timeline_time: RefCell<Option<f32>>,
     /// Temps programme (secondes de sortie) — cf. `FrameGeometryInput::programme_time`.
     programme_time: RefCell<Option<f32>>,
+    /// The frames of cameras 1..=3 (`set_extra_camera_frames`), as addresses (0 = none) so
+    /// the compositor's auto traits stay what they were without the raw pointers.
+    extra_camera_frames: std::cell::Cell<[usize; crate::camera_layers::MAX_EXTRA_CAMERAS]>,
     live_params: RefCell<LiveParams>,
     metal_texture_cache: CVMetalTextureCache,
     /// Dernier command buffer soumis, gardé pour pouvoir l'attendre AU MOMENT où le CPU lit
@@ -729,6 +732,7 @@ impl Compositor {
             footage: std::cell::Cell::new(None),
             timeline_time: RefCell::new(None),
             programme_time: RefCell::new(None),
+            extra_camera_frames: std::cell::Cell::new([0; crate::camera_layers::MAX_EXTRA_CAMERAS]),
             live_params: RefCell::new(LiveParams::default()),
             metal_texture_cache: cache,
             last_cmd: RefCell::new(None),
@@ -836,6 +840,9 @@ impl Compositor {
 
     pub fn set_scene(&self, s: Option<Scene>) {
         *self.scene.borrow_mut() = s;
+        // A new scene can drop the regions that drew an extra camera: forget its frames so a
+        // stale pointer is never drawn before the next `set_extra_camera_frames`.
+        self.extra_camera_frames.set([0; crate::camera_layers::MAX_EXTRA_CAMERAS]);
     }
 
     pub fn set_cursor(&self, track: crate::cursor::CursorTrack) {
@@ -937,6 +944,26 @@ impl Compositor {
     /// IOSurface, pas par pointeur Rust. `flush()` est donc la vidange elle-même.
     pub fn clear_srv_cache(&self) {
         self.metal_texture_cache.flush();
+        // The extra cameras' frames belong to the decoders just closed: forget them too, so
+        // a stale pointer is never read before the next `set_extra_camera_frames`.
+        self.extra_camera_frames.set([0; crate::camera_layers::MAX_EXTRA_CAMERAS]);
+    }
+
+    /// Frames for cameras 1..=3 (index 0 = scene camera 1). A null or missing entry means that
+    /// camera is not drawn this frame. The compositor keeps the pointers and reads them in every
+    /// `compose_frame` until the next call, so they must stay valid until then.
+    pub unsafe fn set_extra_camera_frames(&self, frames: &[*const AVFrame]) {
+        let mut slots = [0usize; crate::camera_layers::MAX_EXTRA_CAMERAS];
+        for (slot, frame) in slots.iter_mut().zip(frames) {
+            *slot = *frame as usize;
+        }
+        self.extra_camera_frames.set(slots);
+    }
+
+    /// The frame set for scene camera `camera` (1..=3), null when there is none.
+    fn extra_camera_frame(&self, camera: usize) -> *const AVFrame {
+        let slots = self.extra_camera_frames.get();
+        camera.checked_sub(1).and_then(|k| slots.get(k).copied()).unwrap_or(0) as *const AVFrame
     }
 
     /// Les verbes de dessin, côté Metal. Mêmes noms et mêmes paramètres que leurs
@@ -1150,13 +1177,15 @@ impl Compositor {
         programme_t: f32,
     ) -> Result<()> {
         let full = [0.0, 0.0, 1.0, 1.0];
-        self.draw_image_in(enc, path, full, [0.0, 0.0], 0.0, output_aspect, motion, programme_t)
+        let (aspect, t) = (output_aspect, programme_t);
+        self.draw_image_in(enc, path, full, [0.0, 0.0], 0.0, aspect, motion, t, 0.0)
     }
 
     /// `draw_image_bg` pour un rect quelconque — la bulle webcam s'en sert avec ses coins
     /// arrondis. `output_aspect` est le ratio du RECT visé, pas celui de la sortie : le crop
     /// « cover » se calcule contre la zone qu'on remplit. `motion` anime l'image au temps
-    /// programme `programme_t` ; la bulle passe `WallpaperMotion::None`.
+    /// programme `programme_t` ; la bulle passe `WallpaperMotion::None`. `transparency` =
+    /// `layer_fx.x` (0 = opaque): a camera layer's background box fades with the layer.
     #[allow(clippy::too_many_arguments)]
     unsafe fn draw_image_in(
         &self,
@@ -1168,6 +1197,7 @@ impl Compositor {
         output_aspect: f32,
         motion: WallpaperMotion,
         programme_t: f32,
+        transparency: f32,
     ) -> Result<()> {
         let (tex, iw, ih) = self.cached_image(path)?;
         let ai = iw as f32 / ih.max(1) as f32;
@@ -1191,6 +1221,7 @@ impl Compositor {
                 mode: 6.0,
                 fx: [0.0, 0.0, anim[0], anim[1]],
                 mb,
+                layer_fx: [transparency, 0.0, 0.0, 0.0],
                 ..Default::default()
             },
         );
@@ -1209,6 +1240,8 @@ impl Compositor {
     ///
     /// `quad_px` / `radius_px` sont ceux de la bulle : le fond doit épouser ses coins arrondis,
     /// sinon un rectangle déborde derrière la caméra.
+    ///
+    /// `transparency` = the camera layer's `layer_fx.x`: the box fades with the camera.
     unsafe fn draw_webcam_bg(
         &self,
         enc: &metal::RenderCommandEncoderRef,
@@ -1216,14 +1249,17 @@ impl Compositor {
         dst: [f32; 4],
         quad_px: [f32; 2],
         radius_px: f32,
+        transparency: f32,
     ) {
         const BLACK: [f32; 4] = [0.0, 0.0, 0.0, 1.0];
+        let layer_fx = [transparency, 0.0, 0.0, 0.0];
         let solid = |color: [f32; 4]| LayerCB {
             dst,
             quad_px,
             radius_px,
             mode: 1.0,
             color,
+            layer_fx,
             ..Default::default()
         };
         match bg {
@@ -1241,6 +1277,7 @@ impl Compositor {
                         quad_px,
                         radius_px,
                         fx: [a.sin(), -a.cos(), 0.0, 0.0],
+                        layer_fx,
                         ..crate::frame_geometry::gradient_layer(stops, offsets, BLACK)
                     },
                 );
@@ -1251,7 +1288,9 @@ impl Compositor {
                 let aspect = if quad_px[1] > 0.0 { quad_px[0] / quad_px[1] } else { 1.0 };
                 let still = WallpaperMotion::None;
                 if let Err(e) =
-                    self.draw_image_in(enc, path, dst, quad_px, radius_px, aspect, still, 0.0)
+                    self.draw_image_in(
+                        enc, path, dst, quad_px, radius_px, aspect, still, 0.0, transparency,
+                    )
                 {
                     eprintln!("[compositor] fond webcam \"{path}\" : {e:#}");
                     self.draw_solid(enc, &solid(BLACK));
@@ -2667,104 +2706,141 @@ impl Compositor {
 
         // --- caméra : ombre PiP puis vidéo ---
         let enc = self.begin_pass(cmd_buf, &self.rt, None, &self.pipeline_main)?;
-        if let (true, Some((wy, wuv))) = (lp.has_webcam, webcam_tex.as_ref()) {
-            let [cu0, cv0, cu1, cv1] = crate::frame_geometry::webcam_source_rect(
-                [wcw, wch],
-                [wtw as f32, wth as f32],
-                if g.webcam.full_frame {
-                    None
-                } else {
-                    scene_ref.as_ref().and_then(|scene| scene.layout.webcam_crop)
-                },
-                g.w_px[0] / g.w_px[1].max(0.0001),
-            );
-            // Mirror and the desk-shot turn are both bound swaps: u for horizontal, v for vertical.
-            let (u0, u1) = if g.webcam.flip_u { (cu1, cu0) } else { (cu0, cu1) };
-            let (v0, v1) = if g.webcam.flip_v { (cv1, cv0) } else { (cv0, cv1) };
-            let webcam_is_block = matches!(
-                g.scene_preset.as_deref(),
-                Some("dual-frame") | Some("vertical-stack")
-            );
-            // Effet d'arrière-plan : le mode vient de la scène, le masque par pixel de
-            // l'inférence. Les DEUX sont requis — un mode sans masque rendrait la webcam
-            // invisible en détourage, donc tant que rien n'a été segmenté on dessine la
-            // piste telle quelle. C'est aussi ce qui rend le premier lancement gracieux.
-            let mask = self.webcam_mask.borrow();
-            let effect = scene_ref
-                .as_ref()
-                .and_then(|s| s.webcam_effect.as_ref())
-                .filter(|_| mask.is_some())
-                .map(|e| (e.shader_code(), e))
-                .filter(|(code, _)| *code > 0.0);
-
-            // L'ombre appartient à la bulle PiP. En détourage il n'y a plus de bulle — une
-            // ombre portée par un rectangle invisible se lit comme un artefact. Le test porte
-            // sur le code de la SCÈNE et non sur celui envoyé au shader : le fond personnalisé
-            // part lui aussi en détourage ci-dessous, mais sa bulle, elle, est bien peinte et
-            // garde donc son ombre.
-            let is_cutout = matches!(effect, Some((code, _)) if code == 1.0);
-            if cfg.shadow && !webcam_is_block && !is_cutout && g.shape_fade > 0.0 {
-                self.draw_shadow(
-                    enc,
-                    g.w_dst,
-                    g.w_px,
-                    g.w_radius,
-                    WEBCAM_SHADOW_SPREAD_FRAC * g.frame_min_px,
-                    [0.0, WEBCAM_SHADOW_OFFSET_FRAC * g.frame_min_px],
-                    WEBCAM_SHADOW_OPACITY * g.shape_fade,
+        // Camera 0's crop, mirror and desk turn as camera settings, plus its homography
+        // (`Scene::camera(0)`): with one, `src` is not read and the crop is dropped.
+        let cam0 = g.camera0_settings(scene_ref.as_ref());
+        let webcam_is_block = matches!(
+            g.scene_preset.as_deref(),
+            Some("dual-frame") | Some("vertical-stack")
+        );
+        // Effet d'arrière-plan : le mode vient de la scène, le masque par pixel de
+        // l'inférence. Les DEUX sont requis — un mode sans masque rendrait la webcam
+        // invisible en détourage, donc tant que rien n'a été segmenté on dessine la
+        // piste telle quelle. C'est aussi ce qui rend le premier lancement gracieux.
+        let mask = self.webcam_mask.borrow();
+        let effect = scene_ref
+            .as_ref()
+            .and_then(|s| s.webcam_effect.as_ref())
+            .filter(|_| mask.is_some())
+            .map(|e| (e.shader_code(), e))
+            .filter(|(code, _)| *code > 0.0);
+        // L'ombre appartient à la bulle PiP. En détourage il n'y a plus de bulle — une
+        // ombre portée par un rectangle invisible se lit comme un artefact. Le test porte
+        // sur le code de la SCÈNE et non sur celui envoyé au shader : le fond personnalisé
+        // part lui aussi en détourage ci-dessous, mais sa bulle, elle, est bien peinte et
+        // garde donc son ombre.
+        let is_cutout = matches!(effect, Some((code, _)) if code == 1.0);
+        // Fond personnalisé : on PEINT le fond dans la bulle, puis on y découpe la caméra
+        // par-dessus — le mélange alpha donne `lerp(fond, caméra, personne)`, soit exactement
+        // ce que la branche « mode 3 » du shader calculait, mais pour les TROIS sortes de
+        // fond. Le shader ne sait peindre qu'une couleur plate sous le masque ; dégradés et
+        // images y tombaient sur du noir, et le défaut EST une image. L'ordre est imposé :
+        // ombre, puis fond, puis caméra. `custom_bg` = Some(background) in that mode.
+        let (effect_code, blur_intensity, custom_bg) = match effect {
+            Some((code, e)) if code > 2.5 => (1.0, 0.0, Some(e.background.as_ref())),
+            Some((code, e)) => (code, e.blur_intensity.clamp(0.0, 1.0), None),
+            None => (0.0, 0.0, None),
+        };
+        // Metal tolère l'index 3 non lié tant que `fx.z` reste à 0 : la branche n'est
+        // pas prise, la texture n'est pas échantillonnée. Dès qu'il monte, elle doit
+        // l'être sur TOUT draw capable de la prendre — ici seul celui de la caméra 0. L'état
+        // d'un encodeur est rémanent, donc lier avant le draw suffit, et l'ombre puis le
+        // fond qui précèdent sont en modes 1/2/5/6, que `ps_main` garde hors de la branche
+        // (`mode < 0.5`). The extra cameras draw with `fx.z = 0` and never read it.
+        //
+        // Pas de déliaison après coup, contrairement au chemin Windows qui remet le slot
+        // t3 à `None` : cet état meurt avec l'encodeur, et les annotations en ouvrent un
+        // autre. Il n'y a rien sur quoi fuir.
+        if let Some(m) = mask.as_ref() {
+            enc.set_fragment_texture(3, Some(&m.tex));
+        }
+        // The extra cameras' textures, held to the end of `compose_frame` like `webcam_tex`.
+        let mut extra_textures = Vec::new();
+        if g.camera_layers.is_empty() {
+            // Without layout regions: camera 0 from `w_dst`, as before the layers.
+            if let (true, Some((wy, wuv))) = (lp.has_webcam, webcam_tex.as_ref()) {
+                // Mirror and the desk-shot turn are both bound swaps: u for horizontal, v for
+                // vertical.
+                let src = crate::frame_geometry::camera_source_rect(
+                    Some(&cam0),
+                    [wcw, wch],
+                    [wtw as f32, wth as f32],
+                    g.w_px[0] / g.w_px[1].max(0.0001),
                 );
+                if cfg.shadow && !webcam_is_block && !is_cutout && g.shape_fade > 0.0 {
+                    self.draw_shadow(
+                        enc,
+                        g.w_dst,
+                        g.w_px,
+                        g.w_radius,
+                        WEBCAM_SHADOW_SPREAD_FRAC * g.frame_min_px,
+                        [0.0, WEBCAM_SHADOW_OFFSET_FRAC * g.frame_min_px],
+                        WEBCAM_SHADOW_OPACITY * g.shape_fade,
+                    );
+                }
+                if let Some(bg) = custom_bg {
+                    self.draw_webcam_bg(enc, bg, g.w_dst, g.w_px, g.w_radius, 0.0);
+                }
+                let cb = g.webcam_video_cb(src, w_valid, effect_code, blur_intensity);
+                let cb = crate::frame_geometry::with_camera_homography(cb, Some(&cam0));
+                self.draw_video(enc, &cb, wy, wuv);
             }
-
-            // Fond personnalisé : on PEINT le fond dans la bulle, puis on y découpe la caméra
-            // par-dessus — le mélange alpha donne `lerp(fond, caméra, personne)`, soit exactement
-            // ce que la branche « mode 3 » du shader calculait, mais pour les TROIS sortes de
-            // fond. Le shader ne sait peindre qu'une couleur plate sous le masque ; dégradés et
-            // images y tombaient sur du noir, et le défaut EST une image. L'ordre est imposé :
-            // ombre, puis fond, puis caméra.
-            let (effect_code, blur_intensity) = match effect {
-                Some((code, e)) if code > 2.5 => {
-                    self.draw_webcam_bg(enc, e.background.as_ref(), g.w_dst, g.w_px, g.w_radius);
-                    (1.0, 0.0)
+        } else {
+            // Every planned layer, in order: shadow, then (camera 0) the custom background,
+            // then the video. Camera 0 keeps its frame, effects and mask; the extra cameras
+            // draw from `set_extra_camera_frames` without effects, and a missing one is skipped.
+            let render = [rw, rh];
+            let cam0_base = g.webcam_video_cb([0.0; 4], w_valid, effect_code, blur_intensity);
+            for plan in &g.camera_layers {
+                if plan.camera == 0 {
+                    let (true, Some((wy, wuv))) = (lp.has_webcam, webcam_tex.as_ref()) else {
+                        continue;
+                    };
+                    let video = crate::frame_geometry::camera_layer_cb(
+                        plan,
+                        Some(&cam0),
+                        [wcw, wch],
+                        [wtw as f32, wth as f32],
+                        render,
+                        &cam0_base,
+                    );
+                    if let Some(shadow) =
+                        g.camera_layer_shadow(plan, &video, render, cfg.shadow, is_cutout)
+                    {
+                        self.draw_solid(enc, &shadow);
+                    }
+                    if let Some(bg) = custom_bg {
+                        let (dst, quad_px, radius_px) = (video.dst, video.quad_px, video.radius_px);
+                        self.draw_webcam_bg(enc, bg, dst, quad_px, radius_px, video.layer_fx[0]);
+                    }
+                    self.draw_video(enc, &video, wy, wuv);
+                } else {
+                    // Tolerant like camera 0: no frame, or no pixel buffer in it, skips the layer.
+                    let frame = self.extra_camera_frame(plan.camera);
+                    let Ok((ey, euv)) = self.nv12_srvs(frame) else { continue };
+                    let (tw, th) = self.tex_dims(frame);
+                    let visible = [(*frame).width as f32, (*frame).height as f32];
+                    let tex = [tw as f32, th as f32];
+                    let valid = [visible[0] / tex[0].max(1.0), visible[1] / tex[1].max(1.0)];
+                    let video = crate::frame_geometry::camera_layer_cb(
+                        plan,
+                        scene_ref.as_ref().and_then(|s| s.camera(plan.camera)),
+                        visible,
+                        tex,
+                        render,
+                        &crate::frame_geometry::extra_camera_base_cb(valid),
+                    );
+                    if let Some(shadow) =
+                        g.camera_layer_shadow(plan, &video, render, cfg.shadow, false)
+                    {
+                        self.draw_solid(enc, &shadow);
+                    }
+                    self.draw_video(enc, &video, &ey, &euv);
+                    extra_textures.push((ey, euv));
                 }
-                Some((code, e)) => (code, e.blur_intensity.clamp(0.0, 1.0)),
-                None => (0.0, 0.0),
-            };
-
-            // Metal tolère l'index 3 non lié tant que `fx.z` reste à 0 : la branche n'est
-            // pas prise, la texture n'est pas échantillonnée. Dès qu'il monte, elle doit
-            // l'être sur TOUT draw capable de la prendre — ici il n'y en a qu'un. L'état
-            // d'un encodeur est rémanent, donc lier avant le draw suffit, et l'ombre puis le
-            // fond qui précèdent sont en modes 1/2/5/6, que `ps_main` garde hors de la branche
-            // (`mode < 0.5`).
-            //
-            // Pas de déliaison après coup, contrairement au chemin Windows qui remet le slot
-            // t3 à `None` : cet état meurt avec l'encodeur, et les annotations en ouvrent un
-            // autre. Il n'y a rien sur quoi fuir.
-            if let Some(m) = mask.as_ref() {
-                enc.set_fragment_texture(3, Some(&m.tex));
             }
-            self.draw_video(
-                enc,
-                &LayerCB {
-                    dst: g.w_dst,
-                    src: [u0, v0, u1, v1],
-                    quad_px: g.w_px,
-                    radius_px: g.w_radius,
-                    mode: 0.0,
-                    // `color.a` porte l'alpha du découpage (`color.a * personne`) ; le RGB n'est
-                    // plus lu, le fond ayant déjà été peint sous la caméra.
-                    color: [0.0, 0.0, 0.0, 1.0],
-                    fx: [w_valid[0], w_valid[1], effect_code, blur_intensity],
-                    src_prev: [u0, v0, u1, v1],
-                    dst_prev: g.w_dst_prev,
-                    mb: [g.mb_taps, g.mb_amount, 1.0, 0.0],
-                    cover: [g.webcam_cover, 0.04 * g.w_px[0].min(g.w_px[1]) * g.webcam_cover, 0.35, 0.0],
-                    ..Default::default()
-                },
-                wy,
-                wuv,
-            );
         }
+        drop(mask);
 
         enc.end_encoding();
 
diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rs
index ebf106f79..74c60b07f 100644
--- a/crates/compositor/src/compositor_windows.rs
+++ b/crates/compositor/src/compositor_windows.rs
@@ -92,6 +92,15 @@ struct DofPyramid {
     height: u32,
 }
 
+/// An extra camera's frame for this `compose_frame`: its private copy's plane views, and the
+/// visible and texture sizes `camera_layer_cb` crops against.
+struct ExtraCamera {
+    y: ID3D11ShaderResourceView,
+    uv: ID3D11ShaderResourceView,
+    visible: [f32; 2],
+    tex: [f32; 2],
+}
+
 pub struct Compositor {
     dev: ID3D11Device,
     ctx: ID3D11DeviceContext,
@@ -171,6 +180,9 @@ pub struct Compositor {
     /// the copy's size and format on every hit, so a new texture landing on an old address
     /// is never handed a copy sized for the old one. `clear_srv_cache` frees stale entries.
     srv_cache: RefCell<HashMap<usize, (ID3D11Texture2D, ID3D11ShaderResourceView, ID3D11ShaderResourceView)>>,
+    /// The frames of cameras 1..=3 (`set_extra_camera_frames`), as addresses (0 = none) so
+    /// the compositor's auto traits stay what they were without the raw pointers.
+    extra_camera_frames: Cell<[usize; crate::camera_layers::MAX_EXTRA_CAMERAS]>,
     live_params: RefCell<LiveParams>,
     /// Scène pilotée par l'app (contrat) : quand présente, remplace le layout fixture de
     /// `timeline()`. Voir `scene.rs` / `SceneDescription` (TS).
@@ -762,6 +774,7 @@ impl Compositor {
             timeline_t_override: RefCell::new(None),
             programme_time: RefCell::new(None),
             srv_cache: RefCell::new(HashMap::new()),
+            extra_camera_frames: Cell::new([0; crate::camera_layers::MAX_EXTRA_CAMERAS]),
             live_params: RefCell::new(LiveParams::default()),
             scene: RefCell::new(None),
             text_raster: match crate::text::TextRasterizer::new() {
@@ -840,6 +853,53 @@ impl Compositor {
     /// depuis le layout preset au lieu du planning fixture.
     pub fn set_scene(&self, s: Option<Scene>) {
         *self.scene.borrow_mut() = s;
+        // A new scene can drop the regions that drew an extra camera: forget its frames so a
+        // stale pointer is never drawn before the next `set_extra_camera_frames`.
+        self.extra_camera_frames.set([0; crate::camera_layers::MAX_EXTRA_CAMERAS]);
+    }
+
+    /// Frames for cameras 1..=3 (index 0 = scene camera 1). A null or missing entry means that
+    /// camera is not drawn this frame. The compositor keeps the pointers and reads them in every
+    /// `compose_frame` until the next call, so they must stay valid until then. They go through
+    /// `nv12_srvs` and its cache like camera 0's frame (`clear_srv_cache` clears them alike).
+    pub unsafe fn set_extra_camera_frames(&self, frames: &[*const AVFrame]) {
+        let mut slots = [0usize; crate::camera_layers::MAX_EXTRA_CAMERAS];
+        for (slot, frame) in slots.iter_mut().zip(frames) {
+            *slot = *frame as usize;
+        }
+        self.extra_camera_frames.set(slots);
+    }
+
+    /// The frame set for scene camera `camera` (1..=3), null when there is none.
+    fn extra_camera_frame(&self, camera: usize) -> *const AVFrame {
+        let slots = self.extra_camera_frames.get();
+        camera.checked_sub(1).and_then(|k| slots.get(k).copied()).unwrap_or(0) as *const AVFrame
+    }
+
+    /// The copies (`nv12_srvs`) of every extra camera `layers` draws, with their visible and
+    /// texture sizes. Tolerant: a camera without a frame, or whose frame has no D3D11 texture,
+    /// is `None` and simply not drawn.
+    unsafe fn extra_camera_srvs(
+        &self,
+        layers: &[crate::camera_layers::CameraLayerPlan],
+    ) -> [Option<ExtraCamera>; crate::camera_layers::MAX_EXTRA_CAMERAS] {
+        let mut out: [Option<ExtraCamera>; crate::camera_layers::MAX_EXTRA_CAMERAS] =
+            Default::default();
+        for (k, slot) in out.iter_mut().enumerate() {
+            let frame = self.extra_camera_frame(k + 1);
+            if frame.is_null() || !layers.iter().any(|l| l.camera == k + 1) {
+                continue;
+            }
+            let Ok((y, uv)) = self.nv12_srvs(frame) else { continue };
+            let (tw, th) = self.tex_dims(frame);
+            *slot = Some(ExtraCamera {
+                y,
+                uv,
+                visible: [(*frame).width as f32, (*frame).height as f32],
+                tex: [tw as f32, th as f32],
+            });
+        }
+        out
     }
 
     /// The Y (R8) and UV (R8G8) views of the decoder frame — over a private COPY, never
@@ -1227,13 +1287,14 @@ impl Compositor {
         programme_t: f32,
     ) -> Result<()> {
         let full = [0.0, 0.0, 1.0, 1.0];
-        self.draw_image_in(path, full, [0.0, 0.0], 0.0, output_aspect, motion, programme_t)
+        self.draw_image_in(path, full, [0.0, 0.0], 0.0, output_aspect, motion, programme_t, 0.0)
     }
 
     /// `draw_image_bg` pour un rect quelconque — la bulle webcam s'en sert avec ses coins
     /// arrondis. `output_aspect` est le ratio du RECT visé, pas celui de la sortie : le crop
     /// « cover » se calcule contre la zone qu'on remplit. `motion` anime l'image au temps
-    /// programme `programme_t` ; la bulle passe `WallpaperMotion::None`.
+    /// programme `programme_t` ; la bulle passe `WallpaperMotion::None`. `transparency` =
+    /// `layer_fx.x` (0 = opaque): a camera layer's background box fades with the layer.
     #[allow(clippy::too_many_arguments)]
     unsafe fn draw_image_in(
         &self,
@@ -1244,6 +1305,7 @@ impl Compositor {
         output_aspect: f32,
         motion: WallpaperMotion,
         programme_t: f32,
+        transparency: f32,
     ) -> Result<()> {
         let (srv, iw, ih) = self.cached_image(path)?;
         let ai = iw as f32 / ih as f32;
@@ -1268,6 +1330,7 @@ impl Compositor {
             mode: 6.0,
             fx: [0.0, 0.0, anim[0], anim[1]],
             mb,
+            layer_fx: [transparency, 0.0, 0.0, 0.0],
             ..Default::default()
         });
         Ok(())
@@ -1285,20 +1348,25 @@ impl Compositor {
     ///
     /// `quad_px` / `radius_px` sont ceux de la bulle : le fond doit épouser ses coins arrondis,
     /// sinon un rectangle déborde derrière la caméra.
+    ///
+    /// `transparency` = the camera layer's `layer_fx.x`: the box fades with the camera.
     unsafe fn draw_webcam_bg(
         &self,
         bg: Option<&SceneBackground>,
         dst: [f32; 4],
         quad_px: [f32; 2],
         radius_px: f32,
+        transparency: f32,
     ) {
         const BLACK: [f32; 4] = [0.0, 0.0, 0.0, 1.0];
+        let layer_fx = [transparency, 0.0, 0.0, 0.0];
         let solid = |color: [f32; 4]| LayerCB {
             dst,
             quad_px,
             radius_px,
             mode: 1.0,
             color,
+            layer_fx,
             ..Default::default()
         };
         match bg {
@@ -1315,6 +1383,7 @@ impl Compositor {
                     quad_px,
                     radius_px,
                     fx: [dir[0], dir[1], 0.0, 0.0],
+                    layer_fx,
                     ..crate::frame_geometry::gradient_layer(stops, offsets, BLACK)
                 });
             }
@@ -1324,7 +1393,9 @@ impl Compositor {
                 let aspect = if quad_px[1] > 0.0 { quad_px[0] / quad_px[1] } else { 1.0 };
                 let still = WallpaperMotion::None;
                 if let Err(e) =
-                    self.draw_image_in(path, dst, quad_px, radius_px, aspect, still, 0.0)
+                    self.draw_image_in(
+                        path, dst, quad_px, radius_px, aspect, still, 0.0, transparency,
+                    )
                 {
                     eprintln!("[compositor] fond webcam \"{}\" : {:#}", path, e);
                     self.draw_solid(&solid(BLACK));
@@ -2022,8 +2093,9 @@ impl Compositor {
             programme_time: *self.programme_time.borrow(),
         });
         self.footage.set(Some(g.footage_quad([self.rw(), self.rh()])));
+        // The extra cameras' copies, made before anything is drawn like the two above.
+        let extra_cams = self.extra_camera_srvs(&g.camera_layers);
         let scene_preset = g.scene_preset.clone();
-        let mb_taps = g.mb_taps;
         let mb_amount = g.mb_amount;
         let source_t = g.source_t;
         let _padding_scale = g.padding_scale;
@@ -2034,7 +2106,6 @@ impl Compositor {
         let s_radius = g.s_radius;
         let frame_min_px = g.frame_min_px;
         let w_dst = g.w_dst;
-        let w_dst_prev = g.w_dst_prev;
         let w_px = g.w_px;
         let w_radius = g.w_radius;
         let shape_fade = g.shape_fade;
@@ -2435,103 +2506,144 @@ impl Compositor {
         //
         // Le center-crop carré de square/circle en est un cas particulier (boîte 1:1) — il n'a
         // plus besoin d'être traité à part.
-        let [su0, sv0, su1, sv1] = crate::frame_geometry::webcam_source_rect(
-            [wcw, wch],
-            [wtw as f32, wth as f32],
-            if g.webcam.full_frame {
-                None
-            } else {
-                scene_ref.as_ref().and_then(|scene| scene.layout.webcam_crop)
-            },
-            w_px[0] / w_px[1].max(0.0001),
+        // Camera 0's crop, mirror and desk turn as camera settings, plus its homography
+        // (`Scene::camera(0)`): with one, `src` is not read and the crop is dropped.
+        let cam0 = g.camera0_settings(scene_ref.as_ref());
+        // L'ombre portée appartient à la bulle flottante PiP : elle se retire avec elle
+        // (`shape_fade`), pour qu'au plein écran plus rien n'encadre la caméra. C'est une
+        // ombre légère NON paramétrable — indépendante du slider Shadow, qui ne pilote plus
+        // que l'écran (`WEBCAM_SHADOW_OPACITY`, pas `shadow_scale`) — et propre au PiP : les
+        // blocs side-by-side / top-bottom soudent la caméra à l'écran et n'en portent aucune
+        // (parité `preset.shadow` web, `null` hors PiP dans `compositeLayout.ts`).
+        let webcam_is_block = matches!(
+            scene_preset.as_deref(),
+            Some("dual-frame") | Some("vertical-stack"),
         );
-        // Mirror and the desk-shot turn are both bound swaps: u for horizontal, v for vertical.
-        let (u0, u1) = if g.webcam.flip_u { (su1, su0) } else { (su0, su1) };
-        let (v0, v1) = if g.webcam.flip_v { (sv1, sv0) } else { (sv0, sv1) };
-        if lp.has_webcam {
-            // L'ombre portée appartient à la bulle flottante PiP : elle se retire avec elle
-            // (`shape_fade`), pour qu'au plein écran plus rien n'encadre la caméra. C'est une
-            // ombre légère NON paramétrable — indépendante du slider Shadow, qui ne pilote plus
-            // que l'écran (`WEBCAM_SHADOW_OPACITY`, pas `shadow_scale`) — et propre au PiP : les
-            // blocs side-by-side / top-bottom soudent la caméra à l'écran et n'en portent aucune
-            // (parité `preset.shadow` web, `null` hors PiP dans `compositeLayout.ts`).
-            let webcam_is_block = matches!(
-                scene_preset.as_deref(),
-                Some("dual-frame") | Some("vertical-stack"),
-            );
-            // L'ombre appartient à la bulle PiP. En détourage il n'y a plus de bulle — une
-            // ombre portée par un rectangle invisible se lit comme un artefact.
-            let is_cutout = matches!(
-                scene_ref.as_ref().and_then(|s| s.webcam_effect.as_ref()),
-                Some(e) if e.shader_code() == 1.0
-            ) && self.webcam_mask.borrow().is_some();
-            if cfg.shadow && !webcam_is_block && !is_cutout && shape_fade > 0.0 {
-                let strength = WEBCAM_SHADOW_OPACITY * shape_fade;
-                self.draw_shadow(
-                    w_dst,
-                    w_px,
-                    w_radius,
-                    WEBCAM_SHADOW_SPREAD_FRAC * frame_min_px,
-                    [0.0, WEBCAM_SHADOW_OFFSET_FRAC * frame_min_px],
-                    strength,
-                );
-            }
-            // Effet d'arrière-plan : le mode vient de la scène, le masque par pixel de
-            // l'inférence. Les DEUX sont requis — un mode sans masque rendrait la webcam
-            // invisible en détourage, donc tant que rien n'a été segmenté on dessine la piste
-            // telle quelle. C'est aussi ce qui rend le premier lancement gracieux.
-            let mask = self.webcam_mask.borrow();
-            let effect = scene_ref
-                .as_ref()
-                .and_then(|s| s.webcam_effect.as_ref())
-                .filter(|_| mask.is_some())
-                .map(|e| (e.shader_code(), e))
-                .filter(|(code, _)| *code > 0.0);
-
-            // Fond personnalisé : on PEINT le fond dans la bulle, puis on y découpe la caméra
-            // par-dessus — le mélange alpha donne `lerp(fond, caméra, personne)`, soit exactement
-            // ce que la branche « mode 3 » du shader calculait, mais pour les TROIS sortes de
-            // fond. Le shader ne sait peindre qu'une couleur plate sous le masque ; dégradés et
-            // images y tombaient sur du noir, et le défaut EST une image.
-            let (effect_code, blur_intensity) = match effect {
-                Some((code, e)) if code > 2.5 => {
-                    self.draw_webcam_bg(e.background.as_ref(), w_dst, w_px, w_radius);
-                    (1.0, 0.0)
-                }
-                Some((code, e)) => (code, e.blur_intensity.clamp(0.0, 1.0)),
-                None => (0.0, 0.0),
-            };
-
+        // L'ombre appartient à la bulle PiP. En détourage il n'y a plus de bulle — une
+        // ombre portée par un rectangle invisible se lit comme un artefact.
+        let is_cutout = matches!(
+            scene_ref.as_ref().and_then(|s| s.webcam_effect.as_ref()),
+            Some(e) if e.shader_code() == 1.0
+        ) && self.webcam_mask.borrow().is_some();
+        // Effet d'arrière-plan : le mode vient de la scène, le masque par pixel de
+        // l'inférence. Les DEUX sont requis — un mode sans masque rendrait la webcam
+        // invisible en détourage, donc tant que rien n'a été segmenté on dessine la piste
+        // telle quelle. C'est aussi ce qui rend le premier lancement gracieux.
+        let mask = self.webcam_mask.borrow();
+        let effect = scene_ref
+            .as_ref()
+            .and_then(|s| s.webcam_effect.as_ref())
+            .filter(|_| mask.is_some())
+            .map(|e| (e.shader_code(), e))
+            .filter(|(code, _)| *code > 0.0);
+        // Fond personnalisé : on PEINT le fond dans la bulle, puis on y découpe la caméra
+        // par-dessus — le mélange alpha donne `lerp(fond, caméra, personne)`, soit exactement
+        // ce que la branche « mode 3 » du shader calculait, mais pour les TROIS sortes de
+        // fond. Le shader ne sait peindre qu'une couleur plate sous le masque ; dégradés et
+        // images y tombaient sur du noir, et le défaut EST une image.
+        // `custom_bg` = Some(background) in that mode; it is painted between shadow and camera.
+        let (effect_code, blur_intensity, custom_bg) = match effect {
+            Some((code, e)) if code > 2.5 => (1.0, 0.0, Some(e.background.as_ref())),
+            Some((code, e)) => (code, e.blur_intensity.clamp(0.0, 1.0), None),
+            None => (0.0, 0.0, None),
+        };
+        // Camera 0's video draw: the mask, bound to slot 3 for this draw only. `draw_video` ne
+        // lie que les slots 0-1, donc le masque posé ici tient pour l'appel qui suit. Il est
+        // délié juste après pour ne pas fuir sur les calques d'annotation, qui utilisent eux
+        // aussi le slot 2 et au-delà.
+        let draw_camera0 = |cb: &LayerCB| {
             if let Some(m) = mask.as_ref() {
-                // `draw_video` ne lie que les slots 0-1, donc le masque posé ici tient pour
-                // l'appel qui suit. Il est délié juste après pour ne pas fuir sur les calques
-                // d'annotation, qui utilisent eux aussi le slot 2 et au-delà.
                 self.ctx.PSSetShaderResources(3, Some(&[Some(m.srv.clone())]));
             }
-            self.draw_video(
-                &LayerCB {
-                    dst: w_dst,
-                    src: [u0, v0, u1, v1],
-                    quad_px: w_px,
-                    radius_px: w_radius,
-                    mode: 0.0,
-                    // `color.a` porte l'alpha du découpage (`color.a * personne`) ; le RGB n'est
-                    // plus lu, le fond ayant déjà été peint sous la caméra.
-                    color: [0.0, 0.0, 0.0, 1.0],
-                    fx: [w_valid[0], w_valid[1], effect_code, blur_intensity],
-                    src_prev: [u0, v0, u1, v1], // src fixe (pas de zoom webcam)
-                    dst_prev: w_dst_prev,
-                    mb: [mb_taps, mb_amount, 1.0, 0.0],
-                    cover: [g.webcam_cover, 0.04 * w_px[0].min(w_px[1]) * g.webcam_cover, 0.35, 0.0],
-                    ..Default::default()
-                },
-                &wy,
-                &wuv,
-            );
+            self.draw_video(cb, &wy, &wuv);
             if mask.is_some() {
                 self.ctx.PSSetShaderResources(3, Some(&[None]));
             }
+        };
+
+        if g.camera_layers.is_empty() {
+            // Without layout regions: camera 0 from `w_dst`, as before the layers.
+            let [u0, v0, u1, v1] = crate::frame_geometry::camera_source_rect(
+                Some(&cam0),
+                [wcw, wch],
+                [wtw as f32, wth as f32],
+                w_px[0] / w_px[1].max(0.0001),
+            );
+            if lp.has_webcam {
+                if cfg.shadow && !webcam_is_block && !is_cutout && shape_fade > 0.0 {
+                    let strength = WEBCAM_SHADOW_OPACITY * shape_fade;
+                    self.draw_shadow(
+                        w_dst,
+                        w_px,
+                        w_radius,
+                        WEBCAM_SHADOW_SPREAD_FRAC * frame_min_px,
+                        [0.0, WEBCAM_SHADOW_OFFSET_FRAC * frame_min_px],
+                        strength,
+                    );
+                }
+                if let Some(bg) = custom_bg {
+                    self.draw_webcam_bg(bg, w_dst, w_px, w_radius, 0.0);
+                }
+                let cb = g.webcam_video_cb([u0, v0, u1, v1], w_valid, effect_code, blur_intensity);
+                draw_camera0(&crate::frame_geometry::with_camera_homography(cb, Some(&cam0)));
+            }
+        } else {
+            // Every planned layer, in order: shadow, then (camera 0) the custom background,
+            // then the video. Camera 0 keeps its frame, effects and mask; the extra cameras
+            // draw from `set_extra_camera_frames` without effects, and a missing one is skipped.
+            let render = [self.rw(), self.rh()];
+            let cam0_base = g.webcam_video_cb([0.0; 4], w_valid, effect_code, blur_intensity);
+            for plan in &g.camera_layers {
+                if plan.camera == 0 {
+                    if !lp.has_webcam {
+                        continue;
+                    }
+                    let video = crate::frame_geometry::camera_layer_cb(
+                        plan,
+                        Some(&cam0),
+                        [wcw, wch],
+                        [wtw as f32, wth as f32],
+                        render,
+                        &cam0_base,
+                    );
+                    if let Some(shadow) =
+                        g.camera_layer_shadow(plan, &video, render, cfg.shadow, is_cutout)
+                    {
+                        self.draw_solid(&shadow);
+                    }
+                    if let Some(bg) = custom_bg {
+                        let t = video.layer_fx[0];
+                        self.draw_webcam_bg(bg, video.dst, video.quad_px, video.radius_px, t);
+                    }
+                    draw_camera0(&video);
+                } else {
+                    let Some(cam) = extra_cams.get(plan.camera - 1).and_then(|c| c.as_ref())
+                    else {
+                        continue;
+                    };
+                    let settings = scene_ref.as_ref().and_then(|s| s.camera(plan.camera));
+                    let valid = [
+                        cam.visible[0] / cam.tex[0].max(1.0),
+                        cam.visible[1] / cam.tex[1].max(1.0),
+                    ];
+                    let video = crate::frame_geometry::camera_layer_cb(
+                        plan,
+                        settings,
+                        cam.visible,
+                        cam.tex,
+                        render,
+                        &crate::frame_geometry::extra_camera_base_cb(valid),
+                    );
+                    if let Some(shadow) =
+                        g.camera_layer_shadow(plan, &video, render, cfg.shadow, false)
+                    {
+                        self.draw_solid(&shadow);
+                    }
+                    self.draw_video(&video, &cam.y, &cam.uv);
+                }
+            }
         }
+        drop(mask);
 
         // --- annotations : calque le plus haut, comme dans le DOM de la preview (le calque y est
         // monté après la vidéo). Ancrées sur `s_ann`, le rect ÉCRAN SANS ZOOM — c'est le conteneur
@@ -3389,6 +3501,9 @@ impl Compositor {
     /// (p.ex. après un export) pour ne pas retenir indéfiniment des textures de pool.
     pub fn clear_srv_cache(&self) {
         self.srv_cache.borrow_mut().clear();
+        // The extra cameras' frames belong to the decoders just closed: forget them too, so
+        // a stale pointer is never read before the next `set_extra_camera_frames`.
+        self.extra_camera_frames.set([0; crate::camera_layers::MAX_EXTRA_CAMERAS]);
     }
 }
 
diff --git a/crates/compositor/src/extra_cameras.rs b/crates/compositor/src/extra_cameras.rs
new file mode 100644
index 000000000..0b2833c84
--- /dev/null
+++ b/crates/compositor/src/extra_cameras.rs
@@ -0,0 +1,241 @@
+//! The extra cameras (k >= 1) a camera layout region draws, shared by the live preview
+//! (`live.rs`) and the export walk (`timeline_walk.rs`).
+//!
+//! Index convention: camera 0 is the clip's `webcam`; camera k >= 1 is
+//! `additional_cameras[k - 1]`. Only the cameras a non-empty layout region shows are opened,
+//! and each is decoded only near those regions (`extra_camera_active`). Unlike camera 0, an
+//! extra camera never shortens a clip and never holds its last picture: past its end its
+//! layer disappears.
+
+use crate::camera_layers::MAX_EXTRA_CAMERAS;
+use crate::ffi::AVFrame;
+use crate::live::PREFETCH_LEAD_SEC;
+use crate::pipeline::Decoder;
+use crate::scene::{SceneCameraLayoutRegion, SceneClipCamera};
+use crate::timeline_walk::{frame_step, FrameStep, NextFrameTime};
+use anyhow::Result;
+use std::collections::{HashMap, HashSet};
+
+/// An extra camera of an export clip: its file and its offset
+/// (camera source time = screen source time - `offset_sec`).
+pub type ClipCamera = SceneClipCamera;
+
+/// What a clip opens for its extra cameras: index k-1 = camera k, `None` = not opened (no
+/// layout region of the clip shows it, or the clip has no file for it). No extra camera at all
+/// is the empty list.
+pub(crate) type ExtraCameraKeys = Vec<Option<SceneClipCamera>>;
+
+/// Re-seek an extra camera instead of decoding forward when its target is further ahead than
+/// this (it sat idle between two regions).
+pub(crate) const EXTRA_RESEEK_SEC: f64 = 1.0;
+
+/// Camera indices >= 1 that the non-empty `regions` draw, sorted, without duplicates.
+pub(crate) fn cameras_in_regions(regions: &[SceneCameraLayoutRegion]) -> Vec<usize> {
+    let mut cameras: Vec<usize> = regions
+        .iter()
+        .filter(|r| r.end_sec > r.start_sec)
+        .flat_map(|r| r.layers.iter().map(|l| l.camera))
+        .filter(|camera| (1..=MAX_EXTRA_CAMERAS).contains(camera))
+        .collect();
+    cameras.sort_unstable();
+    cameras.dedup();
+    cameras
+}
+
+pub(crate) fn has_camera_file(camera: Option<&SceneClipCamera>) -> bool {
+    camera.is_some_and(|c| !c.path.trim().is_empty())
+}
+
+/// The slots to open for `cameras` from a clip's camera files (`sources[k-1]` = camera k).
+pub(crate) fn extra_camera_keys(cameras: &[usize], sources: &[SceneClipCamera]) -> ExtraCameraKeys {
+    let mut keys: ExtraCameraKeys = (1..=MAX_EXTRA_CAMERAS)
+        .map(|k| {
+            let source = sources.get(k - 1);
+            if cameras.contains(&k) && has_camera_file(source) {
+                source.cloned()
+            } else {
+                None
+            }
+        })
+        .collect();
+    while keys.last().is_some_and(|k| k.is_none()) {
+        keys.pop();
+    }
+    keys
+}
+
+/// Is extra camera `camera` near one of its layout regions at screen source time `t` — from
+/// `PREFETCH_LEAD_SEC` before the region to its end? Outside, its decoder stays idle.
+pub(crate) fn extra_camera_active(regions: &[SceneCameraLayoutRegion], camera: usize, t: f64) -> bool {
+    regions.iter().any(|r| {
+        r.end_sec > r.start_sec
+            && r.layers.iter().any(|l| l.camera == camera)
+            && (r.start_sec - PREFETCH_LEAD_SEC..=r.end_sec).contains(&t)
+    })
+}
+
+/// A camera's source time at screen source time `screen_t` (`camera = screen - offset`),
+/// never before the file's start. Camera 0 (`live.rs`) and the extra cameras share it.
+pub(crate) fn camera_source_time(screen_t: f64, offset_sec: f64) -> f64 {
+    (screen_t - offset_sec).max(0.0)
+}
+
+/// An extra camera's open result: a file that will not open is `None` with one warning line,
+/// and its layer is skipped — never drawn from another source.
+pub(crate) fn opened_or_skipped<T>(path: &str, opened: Result<T>) -> Option<T> {
+    match opened {
+        Ok(dec) => Some(dec),
+        Err(e) => {
+            eprintln!("WARNING: extra camera unreadable ({path}): {e:#}. Its layer will not be drawn.");
+            None
+        }
+    }
+}
+
+/// Opens `path` into `decs` once. A file that will not open is remembered in `unreadable`
+/// and never tried again, so its layer is skipped for the whole export. `true` when `decs`
+/// holds a decoder for `path`.
+pub(crate) fn open_once<T>(
+    decs: &mut HashMap<String, T>,
+    unreadable: &mut HashSet<String>,
+    path: &str,
+    open: impl FnOnce(&str) -> Result<T>,
+) -> bool {
+    if decs.contains_key(path) {
+        return true;
+    }
+    if unreadable.contains(path) {
+        return false;
+    }
+    match opened_or_skipped(path, open(path)) {
+        Some(dec) => {
+            decs.insert(path.to_string(), dec);
+            true
+        }
+        None => {
+            unreadable.insert(path.to_string());
+            false
+        }
+    }
+}
+
+/// The list `set_extra_camera_frames` takes: null for an empty slot, else `frame` of the camera
+/// (itself null when it has nothing to show).
+pub(crate) fn extra_frame_list<T>(
+    extra: &[Option<T>],
+    frame: impl Fn(&T) -> *const AVFrame,
+) -> Vec<*const AVFrame> {
+    extra.iter().map(|slot| slot.as_ref().map_or(std::ptr::null(), &frame)).collect()
+}
+
+/// Advances `dec` to `target` (camera source time) with the webcam's hold semantics
+/// (`frame_step`); re-seeks after an idle stretch or a jump back. Null past the camera's last
+/// frame. `ended_at` is the camera source time past which the file has no frame left: the
+/// decoder is not asked again until the target moves back before it.
+pub(crate) unsafe fn step_extra_camera(
+    dec: &mut Decoder,
+    ended_at: &mut Option<f64>,
+    target: f64,
+) -> Result<*const AVFrame> {
+    if ended_at.is_some_and(|end| target >= end) {
+        return Ok(std::ptr::null());
+    }
+    let frame_dur = 1.0 / dec.fps().max(1.0);
+    let cur = dec.cur_frame();
+    let far = cur.is_null() || {
+        let t = dec.cur_time_sec();
+        target < t - frame_dur * 0.5 || target > t + EXTRA_RESEEK_SEC
+    };
+    let frame = if far {
+        dec.seek_to(target)?
+    } else {
+        let mut frame = cur;
+        let mut guard = 0u32;
+        loop {
+            let next = dec.peek_next_time_sec()?;
+            // Unlike camera 0, an extra camera does not hold its last picture: past its
+            // end (one frame's worth of slack) its layer disappears.
+            if matches!(next, NextFrameTime::Eof) && target > dec.cur_time_sec() + frame_dur {
+                frame = std::ptr::null_mut();
+                break;
+            }
+            match frame_step(next, 0.0, target) {
+                FrameStep::Commit => frame = dec.commit_peek()?,
+                FrameStep::CommitAndStop => {
+                    frame = dec.commit_peek()?;
+                    break;
+                }
+                FrameStep::Hold => break,
+            }
+            guard += 1;
+            if guard > 1000 {
+                break;
+            }
+        }
+        frame
+    };
+    Ok(settle(ended_at, frame, target))
+}
+
+/// Seeks `dec` to `target` (camera source time). Null past the camera's last frame.
+pub(crate) unsafe fn seek_extra_camera(
+    dec: &mut Decoder,
+    ended_at: &mut Option<f64>,
+    target: f64,
+) -> Result<*const AVFrame> {
+    if ended_at.is_some_and(|end| target >= end) {
+        return Ok(std::ptr::null());
+    }
+    let frame = dec.seek_to(target)?;
+    Ok(settle(ended_at, frame, target))
+}
+
+fn settle(ended_at: &mut Option<f64>, frame: *mut AVFrame, target: f64) -> *const AVFrame {
+    *ended_at = if frame.is_null() { Some(target) } else { None };
+    frame
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::anyhow;
+
+    #[test]
+    fn export_skips_an_extra_camera_that_will_not_open() {
+        let mut decs: HashMap<String, u32> = HashMap::new();
+        let mut unreadable = HashSet::new();
+        let mut attempts = 0;
+        let mut refuse = |_: &str| -> Result<u32> {
+            attempts += 1;
+            Err(anyhow!("no such file"))
+        };
+        assert!(!open_once(&mut decs, &mut unreadable, "/cam2.mp4", &mut refuse));
+        // A later clip of the same export does not try the file again.
+        assert!(!open_once(&mut decs, &mut unreadable, "/cam2.mp4", &mut refuse));
+        assert_eq!(attempts, 1);
+        assert!(decs.is_empty());
+
+        // A readable camera opens once and is reused by the next clip.
+        let mut opens = 0;
+        let mut accept = |_: &str| -> Result<u32> {
+            opens += 1;
+            Ok(7)
+        };
+        assert!(open_once(&mut decs, &mut unreadable, "/cam3.mp4", &mut accept));
+        assert!(open_once(&mut decs, &mut unreadable, "/cam3.mp4", &mut accept));
+        assert_eq!(opens, 1);
+        assert_eq!(decs.get("/cam3.mp4"), Some(&7));
+    }
+
+    #[test]
+    fn extra_offsets_move_into_the_screen_clock() {
+        // camera + offset = screen: at offset 2 s, a camera frame at 0.5 s is due at 2.5 s
+        // of screen time, not before.
+        let held = camera_source_time(2.4, 2.0);
+        let due = camera_source_time(2.5, 2.0);
+        assert_eq!(frame_step(NextFrameTime::At(0.5), 0.0, held), FrameStep::Hold);
+        assert_eq!(frame_step(NextFrameTime::At(0.5), 0.0, due), FrameStep::Commit);
+        // Before the camera started, its source time clamps to its first frame.
+        assert_eq!(camera_source_time(1.0, 2.0), 0.0);
+    }
+}
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index a719b9673..9cba80d82 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -27,7 +27,7 @@
 use crate::config::Cfg;
 use crate::scene::{Scene, SceneCrop};
 
-/// Constant buffer d'un calque : **192 octets**, un par draw.
+/// Constant buffer d'un calque : **256 octets**, un par draw.
 ///
 /// C'est le contrat partagé par les trois côtés — `cbuffer Layer` dans `shaders.hlsl`,
 /// `struct Layer` dans `shaders.metal` et `vk_shaders/layer.wgsl`, et ce struct. Ils doivent
@@ -42,6 +42,8 @@ use crate::scene::{Scene, SceneCrop};
 ///
 /// (Le commentaire d'origine annonçait « 64 octets ». Il n'a jamais été juste : dix champs,
 /// trente-deux `f32`. Les trois suivants, le flou de mouvement de l'écran incliné, en font 176, et `cover`, le voile de la vue bureau, 192.)
+/// (The camera layers' homography `persp` and transparency `layer_fx` make it 256: offsets 192
+/// and 240.)
 #[repr(C, align(16))]
 #[derive(Clone, Copy, Default)]
 pub struct LayerCB {
@@ -65,6 +67,14 @@ pub struct LayerCB {
     /// Desk-view cover of the webcam layer: x = strength 0..1, y = blur radius (quad px),
     /// z = dim factor, w unused. Zero everywhere else.
     pub cover: [f32; 4],
+    /// Camera (mode 0) only: the rows of the homography H that maps a point of the layer's
+    /// `dst` quad (0..1, top-left origin) to the camera frame (0..1 of its valid part):
+    /// `[h0, h1, h2, 0], [h3, h4, h5, 0], [h6, h7, h8, 0]`. Read only when `layer_fx.y` is 1;
+    /// `src` is then ignored. Every other mode ignores it.
+    pub persp: [[f32; 4]; 3],
+    /// x = transparency 0..1 (0 = opaque), applied to the output of every mode; y = 1 when
+    /// `persp` applies; z, w = 0. All zero = the layer draws exactly as before the lanes.
+    pub layer_fx: [f32; 4],
 }
 
 impl LayerCB {
@@ -376,6 +386,140 @@ pub(crate) fn webcam_source_rect(
         box_ar,
     )
 }
+
+/// The camera's perspective correction, when it has one whose nine values are all finite. A
+/// matrix with a NaN or an infinity would draw garbage (or nothing), so it counts as none.
+pub(crate) fn camera_homography(camera: Option<&crate::scene::SceneCamera>) -> Option<[f32; 9]> {
+    camera
+        .and_then(|c| c.homography)
+        .filter(|h| h.iter().all(|v| v.is_finite()))
+}
+
+/// The source rect a camera is drawn from: its crop, then a cover-crop to `box_ar`, then its
+/// rotation (180° = both bounds swapped) and mirror (u bounds swapped), `flip_u = mirror ^
+/// turned` as `webcam_orientation` does. A camera without settings is drawn upright and
+/// unmirrored. With a homography, crop, rotation and mirror are all ignored: the corner order
+/// already defines the picture (the shader then does not read `src` at all).
+pub(crate) fn camera_source_rect(
+    camera: Option<&crate::scene::SceneCamera>,
+    visible: [f32; 2],
+    tex: [f32; 2],
+    box_ar: f32,
+) -> [f32; 4] {
+    let corrected = camera_homography(camera).is_some();
+    let settings = camera.filter(|_| !corrected);
+    let [u0, v0, u1, v1] = webcam_source_rect(visible, tex, settings.and_then(|c| c.crop), box_ar);
+    let turned = settings.is_some_and(|c| c.rotation == 180);
+    let mirror = settings.and_then(|c| c.mirror).unwrap_or(false);
+    let (u0, u1) = if mirror ^ turned { (u1, u0) } else { (u0, u1) };
+    let (v0, v1) = if turned { (v1, v0) } else { (v0, v1) };
+    [u0, v0, u1, v1]
+}
+
+/// The window of a corrected picture (`aspect` = its width/height) a box of ratio `box_ar`
+/// shows, as `[u0, v0, du, dv]` of the picture's unit square: centred and cover-fitted, so the
+/// picture is cropped, never stretched — what `cover_uv_rect` does for an uncorrected camera,
+/// whose `src` the shader stops reading once a homography is set. The whole picture without a
+/// usable aspect or box.
+pub(crate) fn corrected_cover_window(aspect: Option<f32>, box_ar: f32) -> [f32; 4] {
+    let Some(aspect) = aspect.filter(|a| a.is_finite() && *a > 0.0) else {
+        return [0.0, 0.0, 1.0, 1.0];
+    };
+    if !(box_ar.is_finite() && box_ar > 0.0) {
+        return [0.0, 0.0, 1.0, 1.0];
+    }
+    if box_ar > aspect {
+        let dv = aspect / box_ar;
+        [0.0, (1.0 - dv) * 0.5, 1.0, dv]
+    } else {
+        let du = box_ar / aspect;
+        [(1.0 - du) * 0.5, 0.0, du, 1.0]
+    }
+}
+
+/// `cb` with the camera's homography in `persp` and `layer_fx.y = 1`; unchanged without one.
+/// The matrix is composed with `corrected_cover_window` for the box `cb.quad_px`, so a box
+/// whose ratio is not the camera's `aspect` (a frame-filling layer, a half of side-by-side)
+/// crops the corrected picture instead of stretching it.
+pub(crate) fn with_camera_homography(
+    mut cb: LayerCB,
+    camera: Option<&crate::scene::SceneCamera>,
+) -> LayerCB {
+    if let Some(h) = camera_homography(camera) {
+        let box_ar = cb.quad_px[0] / cb.quad_px[1];
+        let [u0, v0, du, dv] = corrected_cover_window(camera.and_then(|c| c.aspect), box_ar);
+        // H * C, with C = [[du, 0, u0], [0, dv, v0], [0, 0, 1]] taking box uv to picture uv.
+        let h: [f32; 9] = std::array::from_fn(|i| {
+            let (r, c) = (i / 3, i % 3);
+            match c {
+                0 => h[r * 3] * du,
+                1 => h[r * 3 + 1] * dv,
+                _ => h[r * 3] * u0 + h[r * 3 + 1] * v0 + h[r * 3 + 2],
+            }
+        });
+        cb.persp = [
+            [h[0], h[1], h[2], 0.0],
+            [h[3], h[4], h[5], 0.0],
+            [h[6], h[7], h[8], 0.0],
+        ];
+        cb.layer_fx[1] = 1.0;
+    }
+    cb
+}
+
+/// The video draw of an extra camera before `camera_layer_cb` places it: mode 0, no background
+/// effect (`fx.zw = 0`), `valid` = the valid fraction of its decoder texture, no motion trail.
+pub(crate) fn extra_camera_base_cb(valid: [f32; 2]) -> LayerCB {
+    LayerCB {
+        mode: 0.0,
+        color: [0.0, 0.0, 0.0, 1.0],
+        fx: [valid[0], valid[1], 0.0, 0.0],
+        mb: [1.0, 0.0, 1.0, 0.0],
+        ..Default::default()
+    }
+}
+
+/// The video draw of one planned camera layer: `base` (camera 0's `webcam_video_cb`, or
+/// `extra_camera_base_cb` for the others) moved to the plan's rect, with its corners, its
+/// source rect (`camera_source_rect`), its homography and its transparency (`1 - opacity`).
+/// Planned layers have no motion trail: `dst_prev = dst` and one tap. The exception is camera
+/// 0's untouched default layer (the plan's rect is `base.dst`, fully opaque — what a frame
+/// outside every layout region plans): it keeps `base`'s trail, as on today's path.
+pub(crate) fn camera_layer_cb(
+    plan: &crate::camera_layers::CameraLayerPlan,
+    camera: Option<&crate::scene::SceneCamera>,
+    visible_px: [f32; 2],
+    tex_px: [f32; 2],
+    render: [f32; 2],
+    base: &LayerCB,
+) -> LayerCB {
+    let quad_px = [plan.dst[2] * render[0], plan.dst[3] * render[1]];
+    let min_px = quad_px[0].min(quad_px[1]);
+    let src = camera_source_rect(camera, visible_px, tex_px, quad_px[0] / quad_px[1].max(0.0001));
+    let cover = base.cover[0];
+    let untouched = plan.dst == base.dst && plan.opacity >= 1.0;
+    let (dst_prev, mb) = if untouched {
+        (base.dst_prev, base.mb)
+    } else {
+        (plan.dst, [1.0, 0.0, base.mb[2], base.mb[3]])
+    };
+    with_camera_homography(
+        LayerCB {
+            dst: plan.dst,
+            src,
+            quad_px,
+            radius_px: plan.radius_frac * min_px,
+            src_prev: src,
+            dst_prev,
+            mb,
+            cover: [cover, 0.04 * min_px * cover, base.cover[2], base.cover[3]],
+            persp: [[0.0; 4]; 3],
+            layer_fx: [1.0 - plan.opacity.clamp(0.0, 1.0), 0.0, 0.0, 0.0],
+            ..*base
+        },
+        camera,
+    )
+}
 /// Rétrécit un rect SOURCE déjà exprimé en UV (`[u0, v0, u1, v1]`) autour de son
 /// centre pour qu'il porte le ratio `box_ar` une fois rapporté aux pixels de la
 /// texture. C'est la forme générale de `object-fit: cover`, et LA primitive qui
@@ -1942,6 +2086,10 @@ pub struct FrameGeometry {
     pub webcam: WebcamOrientation,
     /// Desk-view cover strength of the webcam this frame, 0..1 (`camera_fullscreen_cover_at`).
     pub webcam_cover: f32,
+    /// Every camera layer to draw this frame, in draw order (`camera_layers::camera_layers_at`).
+    /// Empty when the scene has no camera layout regions: the backends then draw camera 0 from
+    /// `w_dst` as before. Otherwise camera 0 is in here too, and its `dst`/opacity come from it.
+    pub camera_layers: Vec<crate::camera_layers::CameraLayerPlan>,
     /// Cadre autour de l'écran : chrome de fenêtre plat (mode 14) ou appareil modelé (mode 17).
     /// `None` : aucun, et le rendu est celui d'avant le cadre, à l'octet. `Some` : `s_dst` est
     /// déjà la boîte rétrécie, et `s_radius` le rayon des coins de l'écran — des seuls coins BAS
@@ -2180,6 +2328,109 @@ impl FrameGeometry {
         self.tilt_trail(render_px).filter(|_| !self.screen_trail(render_px))
     }
 
+    /// The camera-0 video draw (mode 0), the same on every backend. `src` = the source rect with
+    /// the mirror / desk turn already applied as swapped bounds (it is also `src_prev`: only
+    /// `dst_prev` carries the motion), `valid` = the valid fraction of the decoder texture,
+    /// `effect_code` / `blur_intensity` = the background effect sent to the shader.
+    pub fn webcam_video_cb(
+        &self,
+        src: [f32; 4],
+        valid: [f32; 2],
+        effect_code: f32,
+        blur_intensity: f32,
+    ) -> LayerCB {
+        LayerCB {
+            dst: self.w_dst,
+            src,
+            quad_px: self.w_px,
+            radius_px: self.w_radius,
+            mode: 0.0,
+            // `color.a` carries the cutout alpha (`color.a * person`); the RGB is not read, the
+            // background has already been painted under the camera.
+            color: [0.0, 0.0, 0.0, 1.0],
+            fx: [valid[0], valid[1], effect_code, blur_intensity],
+            src_prev: src,
+            dst_prev: self.w_dst_prev,
+            mb: [self.mb_taps, self.mb_amount, 1.0, 0.0],
+            cover: [
+                self.webcam_cover,
+                0.04 * self.w_px[0].min(self.w_px[1]) * self.webcam_cover,
+                0.35,
+                0.0,
+            ],
+            ..Default::default()
+        }
+    }
+
+    /// Camera 0's settings as a `SceneCamera`, for `camera_source_rect` / `camera_layer_cb`:
+    /// its orientation is the project mirror and the desk-view turn (`self.webcam`, expressed so
+    /// that `mirror ^ turned` gives back `flip_u`), its crop is the layout's (none for a
+    /// full-frame desk shot), and only its homography and the corrected picture's aspect (so a
+    /// box of another ratio cover-crops it, `with_camera_homography`) come from
+    /// `Scene::camera(0)`.
+    pub(crate) fn camera0_settings(&self, scene: Option<&Scene>) -> crate::scene::SceneCamera {
+        let turned = self.webcam.flip_v;
+        let settings = scene.and_then(|s| s.camera(0));
+        crate::scene::SceneCamera {
+            index: 0,
+            rotation: if turned { 180 } else { 0 },
+            mirror: Some(self.webcam.flip_u ^ turned),
+            crop: if self.webcam.full_frame {
+                None
+            } else {
+                scene.and_then(|s| s.layout.webcam_crop)
+            },
+            homography: settings.and_then(|c| c.homography),
+            aspect: settings.and_then(|c| c.aspect),
+        }
+    }
+
+    /// The drop shadow under a planned camera layer, `video` being its `camera_layer_cb`. Same
+    /// constants as camera 0's PiP shadow, and it fades with the layer (`video.layer_fx.x`).
+    /// None when `shadows_on` is off or the layer fills the frame. Camera 0 also keeps today's
+    /// rules: no shadow in the block presets nor in cutout (`camera0_cutout`), and it leaves
+    /// with the bubble (`shape_fade`).
+    pub(crate) fn camera_layer_shadow(
+        &self,
+        plan: &crate::camera_layers::CameraLayerPlan,
+        video: &LayerCB,
+        render: [f32; 2],
+        shadows_on: bool,
+        camera0_cutout: bool,
+    ) -> Option<LayerCB> {
+        let strength = if plan.camera == 0 {
+            let block = matches!(
+                self.scene_preset.as_deref(),
+                Some("dual-frame") | Some("vertical-stack")
+            );
+            if block || camera0_cutout {
+                return None;
+            }
+            WEBCAM_SHADOW_OPACITY * self.shape_fade
+        } else {
+            WEBCAM_SHADOW_OPACITY
+        };
+        if !shadows_on || plan.fills_frame || strength <= 0.0 {
+            return None;
+        }
+        let spread = WEBCAM_SHADOW_SPREAD_FRAC * self.frame_min_px;
+        let offset = WEBCAM_SHADOW_OFFSET_FRAC * self.frame_min_px;
+        let (sx, sy) = (spread / render[0].max(1.0), spread / render[1].max(1.0));
+        let oy = offset / render[1].max(1.0);
+        let dst = video.dst;
+        Some(LayerCB {
+            dst: [dst[0] - sx, dst[1] - sy + oy, dst[2] + 2.0 * sx, dst[3] + 2.0 * sy],
+            quad_px: [video.quad_px[0] + 2.0 * spread, video.quad_px[1] + 2.0 * spread],
+            radius_px: video.radius_px,
+            mode: 2.0,
+            color: [0.0, 0.0, 0.0, strength],
+            fx: [spread, 0.0, 0.0, 0.0],
+            mb: [0.0, 1.0, 1.0, 0.0],
+            layer_fx: [video.layer_fx[0], 0.0, 0.0, 0.0],
+            ..Default::default()
+        })
+    }
+
     /// Le calque du mode 18 : le rendu isolé de l'écran cadré (t2), recomposé le long de sa
     /// trajectoire. `src` = la coupe (le métrage relu directement là où le rendu isolé s'arrête
     /// au bord de la sortie), `quad_px` et `radius_px` = l'écran et ses coins : ce repli ne lit le
@@ -3019,6 +3270,9 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
         let zoom_regions = scene.map(|s| &s.zoom_regions).unwrap_or(&empty_zoom);
         let cam_regions =
             scene.map(|s| &s.camera_fullscreen_regions).unwrap_or(&empty_cam);
+        // The layout regions, for the seams a Full Camera region shares with them.
+        let empty_layouts: Vec<crate::scene::SceneCameraLayoutRegion> = Vec::new();
+        let layouts = scene.map(|s| &s.camera_layout_regions).unwrap_or(&empty_layouts);
         let webcam_reactive = scene.map(|s| s.layout.webcam_reactive_zoom).unwrap_or(false);
         let source_t = input.timeline_t_override.unwrap_or(frame / FPS);
         // Les transitions se mesurent à l'écran (`ScreenClock`), la frame précédente aussi : une
@@ -3090,16 +3344,22 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
         // Full Camera ignore le rétrécissement réactif de la webcam (design web : mélanger
         // "rétrécit pour le zoom" et "grandit en plein cadre" dans la même frame n'a pas de sens).
         let cam_progress =
-            crate::regions::camera_fullscreen_progress_at(cam_regions, source_t, &clock);
+            crate::regions::camera_fullscreen_progress_at(cam_regions, source_t, &clock, layouts);
         let cam_progress_prev =
-            crate::regions::camera_fullscreen_progress_at(cam_regions, source_t_prev, &clock);
+            crate::regions::camera_fullscreen_progress_at(
+                cam_regions,
+                source_t_prev,
+                &clock,
+                layouts,
+            );
         let shape_fade =
-            crate::regions::camera_fullscreen_shape_at(cam_regions, source_t, &clock);
+            crate::regions::camera_fullscreen_shape_at(cam_regions, source_t, &clock, layouts);
         let webcam = webcam_orientation(
-            crate::regions::camera_fullscreen_region_at(cam_regions, source_t, &clock),
+            crate::regions::camera_fullscreen_region_at(cam_regions, source_t, &clock, layouts),
             lp.webcam_mirror,
         );
-        let webcam_cover = crate::regions::camera_fullscreen_cover_at(cam_regions, source_t, &clock);
+        let webcam_cover =
+            crate::regions::camera_fullscreen_cover_at(cam_regions, source_t, &clock, layouts);
         // rétrécissement réactif : la webcam garde 70 % de sa taille pendant un zoom actif, quel
         // que soit son niveau (elle suivait 1/zoom, et rétrécissait donc d'autant plus que le zoom
         // était profond : ×0,6 au zoom maximal). L'enveloppe est celle de la région : elle descend
@@ -3512,6 +3772,30 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
                     _ => 0.12,
                 },
             };
+        // Camera layout regions: every camera layer of this frame, camera 0 included, on the
+        // same time and clock as Full Camera. Camera 0's default is the layer just planned
+        // above, so a region glides from and back to exactly where `w_dst` puts it. Without
+        // regions nothing is planned, and the backends keep drawing camera 0 from `w_dst`.
+        let camera_layers = match scene {
+            Some(s) if !s.camera_layout_regions.is_empty() => {
+                let default_cam0 = lp.has_webcam.then(|| crate::camera_layers::CameraLayerPlan {
+                    camera: 0,
+                    dst: w_dst,
+                    radius_frac: w_radius / w_px[0].min(w_px[1]).max(1.0),
+                    shape: lp.webcam_shape,
+                    opacity: 1.0,
+                    fills_frame: cam_progress >= 1.0,
+                });
+                crate::camera_layers::camera_layers_at(
+                    &s.camera_layout_regions,
+                    &s.camera_fullscreen_regions,
+                    source_t,
+                    &clock,
+                    default_cam0,
+                )
+            }
+            _ => Vec::new(),
+        };
 
     FrameGeometry {
         scene_preset,
@@ -3545,6 +3829,7 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
         shape_fade,
         webcam,
         webcam_cover,
+        camera_layers,
         window_frame,
         screen_mask,
     }
@@ -7344,7 +7629,7 @@ mod tests {
     #[test]
     fn layer_cb_matches_the_shader_constant_buffer() {
         use std::mem::{align_of, offset_of, size_of};
-        assert_eq!(size_of::<LayerCB>(), 192);
+        assert_eq!(size_of::<LayerCB>(), 256);
         assert_eq!(align_of::<LayerCB>(), 16);
         for (name, got, want) in [
             ("dst", offset_of!(LayerCB, dst), 0),
@@ -7361,11 +7646,333 @@ mod tests {
             ("trail_b", offset_of!(LayerCB, trail_b), 144),
             ("trail_mb", offset_of!(LayerCB, trail_mb), 160),
             ("cover", offset_of!(LayerCB, cover), 176),
+            ("persp", offset_of!(LayerCB, persp), 192),
+            ("layer_fx", offset_of!(LayerCB, layer_fx), 240),
         ] {
             assert_eq!(got, want, "offset de `{name}`");
         }
     }
 
+    /// The camera-0 draw as every backend builds it today leaves both new lanes at zero: no
+    /// homography (`layer_fx.y = 0`) and opaque (`layer_fx.x = 0`), so the shaders take exactly
+    /// the path they took before the lanes existed. The other fields are the ones the three
+    /// backends used to spell out inline.
+    #[test]
+    fn the_webcam_draw_leaves_the_homography_and_transparency_lanes_at_zero() {
+        let cfg = crate::config::all().pop().expect("cfg");
+        let scene = golden_scene();
+        let g = plan_frame(&golden_input(&scene, &cfg));
+        let src = [0.1, 0.2, 0.9, 0.8];
+        let cb = g.webcam_video_cb(src, [1.0, 0.75], 2.0, 0.4);
+        assert_eq!(cb.persp, [[0.0; 4]; 3]);
+        assert_eq!(cb.layer_fx, [0.0; 4]);
+        assert_eq!(cb.dst, g.w_dst);
+        assert_eq!(cb.src, src);
+        assert_eq!(cb.src_prev, src);
+        assert_eq!(cb.quad_px, g.w_px);
+        assert_eq!(cb.radius_px, g.w_radius);
+        assert_eq!(cb.mode, 0.0);
+        assert_eq!(cb.color, [0.0, 0.0, 0.0, 1.0]);
+        assert_eq!(cb.fx, [1.0, 0.75, 2.0, 0.4]);
+        assert_eq!(cb.dst_prev, g.w_dst_prev);
+        assert_eq!(cb.mb, [g.mb_taps, g.mb_amount, 1.0, 0.0]);
+        let min_px = g.w_px[0].min(g.w_px[1]);
+        assert_eq!(cb.cover, [g.webcam_cover, 0.04 * min_px * g.webcam_cover, 0.35, 0.0]);
+    }
+
+    fn extra_camera(index: usize) -> crate::scene::SceneCamera {
+        crate::scene::SceneCamera {
+            index,
+            rotation: 0,
+            mirror: None,
+            crop: None,
+            homography: None,
+            aspect: None,
+        }
+    }
+
+    fn planned(camera: usize, opacity: f32) -> crate::camera_layers::CameraLayerPlan {
+        crate::camera_layers::CameraLayerPlan {
+            camera,
+            dst: [0.5, 0.25, 0.25, 0.5],
+            radius_frac: 0.2,
+            shape: 0,
+            opacity,
+            fills_frame: false,
+        }
+    }
+
+    /// One planned layer's video draw: placed at the plan's rect with its corners, no trail,
+    /// the transparency is `1 - opacity`, and the camera's homography replaces its crop.
+    #[test]
+    fn camera_layer_cb_places_the_layer_and_carries_its_lanes() {
+        let render = [1920.0, 1080.0];
+        let (visible, tex) = ([1280.0, 720.0], [1280.0, 736.0]);
+        let base = extra_camera_base_cb([1.0, 720.0 / 736.0]);
+        let plan = planned(1, 0.25);
+        let plain = camera_layer_cb(&plan, None, visible, tex, render, &base);
+        assert_eq!(plain.dst, plan.dst);
+        assert_eq!(plain.dst_prev, plan.dst);
+        assert_eq!(plain.quad_px, [480.0, 540.0]);
+        assert_eq!(plain.radius_px, 0.2 * 480.0);
+        assert_eq!(plain.layer_fx, [0.75, 0.0, 0.0, 0.0]);
+        assert_eq!(plain.persp, [[0.0; 4]; 3]);
+        assert_eq!(plain.src_prev, plain.src);
+        assert_eq!(plain.mb[0], 1.0);
+        assert_eq!(plain.fx, base.fx);
+
+        // A crop moves the source rect; with a homography as well, the crop is ignored.
+        let crop = SceneCrop { x: 0.5, y: 0.0, width: 0.5, height: 1.0 };
+        let cropped = extra_camera(1);
+        let cropped = crate::scene::SceneCamera { crop: Some(crop), ..cropped };
+        let with_crop = camera_layer_cb(&plan, Some(&cropped), visible, tex, render, &base);
+        assert_ne!(with_crop.src, plain.src);
+        let h = [-1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
+        let corrected = crate::scene::SceneCamera { homography: Some(h), ..cropped.clone() };
+        let warped = camera_layer_cb(&plan, Some(&corrected), visible, tex, render, &base);
+        assert_eq!(warped.layer_fx[1], 1.0);
+        assert_eq!(warped.layer_fx[0], 0.75);
+        let rows = [[-1.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]];
+        assert_eq!(warped.persp, rows);
+        assert_eq!(warped.src, plain.src);
+
+        // Mirror swaps the u bounds only; 180° swaps both, and mirror on top of it un-swaps u.
+        let mirrored = crate::scene::SceneCamera { mirror: Some(true), ..extra_camera(1) };
+        let m = camera_layer_cb(&plan, Some(&mirrored), visible, tex, render, &base).src;
+        assert_eq!(m, [plain.src[2], plain.src[1], plain.src[0], plain.src[3]]);
+        let turned = crate::scene::SceneCamera { rotation: 180, ..extra_camera(1) };
+        let t = camera_layer_cb(&plan, Some(&turned), visible, tex, render, &base).src;
+        assert_eq!(t, [plain.src[2], plain.src[3], plain.src[0], plain.src[1]]);
+        let both = crate::scene::SceneCamera { mirror: Some(true), ..turned.clone() };
+        let b = camera_layer_cb(&plan, Some(&both), visible, tex, render, &base).src;
+        assert_eq!(b, [plain.src[0], plain.src[3], plain.src[2], plain.src[1]]);
+    }
+
+    /// Camera 0's default layer, planned outside every layout region at its own rect and fully
+    /// opaque, keeps its motion trail; moved or faded, it draws without one (R8).
+    #[test]
+    fn camera_0s_untouched_layer_keeps_its_trail() {
+        let render = [1920.0, 1080.0];
+        let base = LayerCB {
+            dst: [0.7, 0.7, 0.2, 0.2],
+            dst_prev: [0.65, 0.7, 0.2, 0.2],
+            mb: [8.0, 0.5, 1.0, 0.0],
+            ..Default::default()
+        };
+        let plan = crate::camera_layers::CameraLayerPlan {
+            camera: 0,
+            dst: base.dst,
+            radius_frac: 0.2,
+            shape: 0,
+            opacity: 1.0,
+            fills_frame: false,
+        };
+        let kept = camera_layer_cb(&plan, None, [64.0; 2], [64.0; 2], render, &base);
+        assert_eq!(kept.dst_prev, base.dst_prev);
+        assert_eq!(kept.mb, base.mb);
+
+        let moved = crate::camera_layers::CameraLayerPlan { dst: [0.1, 0.1, 0.2, 0.2], ..plan };
+        let m = camera_layer_cb(&moved, None, [64.0; 2], [64.0; 2], render, &base);
+        assert_eq!(m.dst_prev, moved.dst);
+        assert_eq!(m.mb, [1.0, 0.0, 1.0, 0.0]);
+
+        let faded = crate::camera_layers::CameraLayerPlan { opacity: 0.5, ..plan };
+        let f = camera_layer_cb(&faded, None, [64.0; 2], [64.0; 2], render, &base);
+        assert_eq!(f.dst_prev, faded.dst);
+        assert_eq!(f.mb, [1.0, 0.0, 1.0, 0.0]);
+    }
+
+    /// A corrected camera in a box of another ratio is cover-cropped, not stretched: the box's
+    /// local uv lands on a centred window of the corrected picture with the box's own ratio.
+    #[test]
+    fn a_corrected_camera_is_cover_fitted_into_its_box() {
+        let identity = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
+        let cam = crate::scene::SceneCamera {
+            homography: Some(identity),
+            aspect: Some(16.0 / 9.0),
+            ..extra_camera(2)
+        };
+        let row = |cb: &LayerCB, r: usize| [cb.persp[r][0], cb.persp[r][1], cb.persp[r][2]];
+        let near = |a: [f32; 3], b: [f32; 3]| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-5);
+
+        // A box narrower than 16:9 (1752x1080, a 1.62 export): the full height, a centred
+        // slice of the width with the box's ratio.
+        let narrow = LayerCB { quad_px: [1752.0, 1080.0], ..Default::default() };
+        let cb = with_camera_homography(narrow, Some(&cam));
+        let du = (1752.0 / 1080.0) / (16.0 / 9.0);
+        assert!(near(row(&cb, 0), [du, 0.0, (1.0 - du) * 0.5]), "{:?}", cb.persp);
+        assert!(near(row(&cb, 1), [0.0, 1.0, 0.0]), "{:?}", cb.persp);
+        assert!(near(row(&cb, 2), [0.0, 0.0, 1.0]), "{:?}", cb.persp);
+
+        // A wider box (a 16:9 picture in a 21:9 box): full width, a centred band of height.
+        let wide = LayerCB { quad_px: [2100.0, 900.0], ..Default::default() };
+        let cb = with_camera_homography(wide, Some(&cam));
+        let dv = (16.0 / 9.0) / (2100.0 / 900.0);
+        assert!(near(row(&cb, 0), [1.0, 0.0, 0.0]), "{:?}", cb.persp);
+        assert!(near(row(&cb, 1), [0.0, dv, (1.0 - dv) * 0.5]), "{:?}", cb.persp);
+
+        // The box the template gives a PiP of this camera has its aspect: nothing is cropped.
+        let pip = LayerCB { quad_px: [422.4, 237.6], ..Default::default() };
+        let cb = with_camera_homography(pip, Some(&cam));
+        assert!(near(row(&cb, 0), [1.0, 0.0, 0.0]) && near(row(&cb, 1), [0.0, 1.0, 0.0]));
+
+        // A real (projective) matrix is composed on the right: H * C, so H's third row picks
+        // up the window too.
+        let h = [0.8, 0.1, 0.05, -0.02, 0.9, 0.04, 0.1, -0.2, 1.0];
+        let cam = crate::scene::SceneCamera { homography: Some(h), ..cam };
+        let cb = with_camera_homography(narrow, Some(&cam));
+        let u0 = (1.0 - du) * 0.5;
+        assert!(near(row(&cb, 2), [0.1 * du, -0.2, 0.1 * u0 + 1.0]), "{:?}", cb.persp);
+        assert_eq!(cb.layer_fx[1], 1.0);
+    }
+
+    /// Without an aspect, or with a degenerate box, the whole corrected picture is shown.
+    #[test]
+    fn the_cover_window_falls_back_to_the_whole_picture() {
+        let whole = [0.0, 0.0, 1.0, 1.0];
+        assert_eq!(corrected_cover_window(None, 1.5), whole);
+        assert_eq!(corrected_cover_window(Some(0.0), 1.5), whole);
+        assert_eq!(corrected_cover_window(Some(1.5), f32::NAN), whole);
+        assert_eq!(corrected_cover_window(Some(1.5), f32::INFINITY), whole);
+        assert_eq!(corrected_cover_window(Some(1.5), 0.0), whole);
+        assert_eq!(corrected_cover_window(Some(1.5), 1.5), whole);
+    }
+
+    /// A homography with a NaN or an infinity in it counts as none.
+    #[test]
+    fn a_non_finite_homography_is_ignored() {
+        let mut h = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
+        let ok = crate::scene::SceneCamera { homography: Some(h), ..extra_camera(1) };
+        assert_eq!(camera_homography(Some(&ok)), Some(h));
+        for bad in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
+            h[7] = bad;
+            let cam = crate::scene::SceneCamera { homography: Some(h), ..extra_camera(1) };
+            assert_eq!(camera_homography(Some(&cam)), None);
+            let cb = with_camera_homography(LayerCB::default(), Some(&cam));
+            assert_eq!(cb.layer_fx, [0.0; 4]);
+            assert_eq!(cb.persp, [[0.0; 4]; 3]);
+        }
+    }
+
+    /// Camera 0's settings give back exactly today's source rect: layout crop, project mirror
+    /// and desk turn, through `camera_source_rect`.
+    #[test]
+    fn camera_0_settings_reproduce_todays_source_rect() {
+        let crop = SceneCrop { x: 0.1, y: 0.2, width: 0.6, height: 0.7 };
+        let (visible, tex, box_ar) = ([1280.0, 720.0], [1280.0, 736.0], 1.3);
+        for (flip_u, flip_v, full_frame) in [
+            (false, false, false),
+            (true, false, false),
+            (false, true, false),
+            (true, true, false),
+            (false, true, true),
+        ] {
+            let mut g = plan_frame(&golden_input(&golden_scene(), &crate::config::all()[0]));
+            g.webcam = WebcamOrientation { flip_u, flip_v, full_frame };
+            let mut scene = golden_scene();
+            scene.layout.webcam_crop = Some(crop);
+            let [cu0, cv0, cu1, cv1] = webcam_source_rect(
+                visible,
+                tex,
+                if full_frame { None } else { Some(crop) },
+                box_ar,
+            );
+            let (u0, u1) = if flip_u { (cu1, cu0) } else { (cu0, cu1) };
+            let (v0, v1) = if flip_v { (cv1, cv0) } else { (cv0, cv1) };
+            let cam0 = g.camera0_settings(Some(&scene));
+            assert!(cam0.homography.is_none());
+            assert_eq!(camera_source_rect(Some(&cam0), visible, tex, box_ar), [u0, v0, u1, v1]);
+        }
+    }
+
+    /// Camera 0 with a perspective is cover-fitted into a box of another ratio, on both paths:
+    /// its default draw in a Full Camera section (no layout region, the box fills the frame)
+    /// and a planned frame-filling layer. Its PiP box, which has the corrected aspect, shows
+    /// the whole corrected picture.
+    #[test]
+    fn camera_0_with_a_perspective_is_cover_fitted_on_both_paths() {
+        let cfg = crate::config::all().pop().expect("cfg");
+        let identity = "[1,0,0,0,1,0,0,0,1]";
+        let aspect = 4.0_f32 / 3.0;
+        let cameras = format!(r#""cameras":[{{"index":0,"homography":{identity},"aspect":{aspect}}}]"#);
+        let zoom = r#""zoomRegions":[{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.3,"rotation":"none"}]"#;
+        let near = |a: f32, b: f32| (a - b).abs() < 1e-4;
+        let render = [1170.0_f32, 658.0];
+        let box_ar = render[0] / render[1];
+        // A 4:3 picture in a wider box: the full width, a centred band of the box's ratio.
+        let dv = aspect / box_ar;
+        let check = |cb: &LayerCB| {
+            assert_eq!(cb.layer_fx[1], 1.0);
+            assert!(near(cb.persp[0][0], 1.0) && near(cb.persp[0][2], 0.0), "{:?}", cb.persp);
+            assert!(near(cb.persp[1][1], dv), "{:?}", cb.persp);
+            assert!(near(cb.persp[1][2], (1.0 - dv) * 0.5), "{:?}", cb.persp);
+        };
+
+        // No layout region, inside a Full Camera section: the default box fills the frame.
+        let json = zoomed_golden_scene_json().replace(
+            zoom,
+            &format!(
+                r#""zoomRegions":[],{cameras},"cameraFullscreenRegions":[{{"clipIndex":0,"startSec":0.0,"endSec":9.0}}]"#
+            ),
+        );
+        let scene = Scene::from_json(&json).expect("scene");
+        let g = plan_frame(&FrameGeometryInput {
+            timeline_t_override: Some(4.0),
+            ..golden_input(&scene, &cfg)
+        });
+        assert!(g.camera_layers.is_empty());
+        assert!(near(g.w_px[0], render[0]) && near(g.w_px[1], render[1]), "{:?}", g.w_px);
+        let cam0 = g.camera0_settings(Some(&scene));
+        assert_eq!(cam0.aspect, Some(aspect));
+        check(&with_camera_homography(
+            g.webcam_video_cb([0.0, 0.0, 1.0, 1.0], [1.0, 1.0], 0.0, 0.0),
+            Some(&cam0),
+        ));
+
+        // A planned layer that fills the frame.
+        let json = zoomed_golden_scene_json().replace(
+            zoom,
+            &format!(
+                r#""zoomRegions":[],{cameras},"cameraLayoutRegions":[{{"clipIndex":0,"startSec":0.0,"endSec":4.0,"layers":[
+                {{"camera":0,"rect":{{"x":0,"y":0,"width":1,"height":1}},"fillsFrame":true}}]}}]"#
+            ),
+        );
+        let scene = Scene::from_json(&json).expect("scene");
+        let g = plan_frame(&golden_input(&scene, &cfg));
+        assert_eq!(g.camera_layers.len(), 1);
+        let cam0 = g.camera0_settings(Some(&scene));
+        let base = g.webcam_video_cb([0.0; 4], [1.0, 1.0], 0.0, 0.0);
+        let plan = g.camera_layers[0];
+        check(&camera_layer_cb(&plan, Some(&cam0), [1280.0, 720.0], [1280.0, 720.0], render, &base));
+
+        // The PiP box the app gives camera 0 has the corrected aspect: nothing is cropped.
+        let pip = LayerCB { quad_px: [400.0, 300.0], ..Default::default() };
+        let cb = with_camera_homography(pip, Some(&cam0));
+        assert!(near(cb.persp[0][0], 1.0) && near(cb.persp[1][1], 1.0), "{:?}", cb.persp);
+    }
+
+    /// The shadow of a planned layer fades with it, and a frame-filling layer has none.
+    #[test]
+    fn a_planned_layers_shadow_fades_with_it() {
+        let cfg = crate::config::all().pop().expect("cfg");
+        let g = plan_frame(&golden_input(&golden_scene(), &cfg));
+        let render = [1920.0, 1080.0];
+        let plan = planned(2, 0.4);
+        let base = extra_camera_base_cb([1.0; 2]);
+        let video = camera_layer_cb(&plan, None, [64.0; 2], [64.0; 2], render, &base);
+        let shadow = g.camera_layer_shadow(&plan, &video, render, true, false).expect("shadow");
+        assert_eq!(shadow.mode, 2.0);
+        assert_eq!(shadow.layer_fx[0], video.layer_fx[0]);
+        assert_eq!(shadow.color[3], WEBCAM_SHADOW_OPACITY);
+        assert!(g.camera_layer_shadow(&plan, &video, render, false, false).is_none());
+        let full = crate::camera_layers::CameraLayerPlan { fills_frame: true, ..plan };
+        assert!(g.camera_layer_shadow(&full, &video, render, true, false).is_none());
+        // Cutout removes camera 0's bubble, not the others'.
+        assert!(g.camera_layer_shadow(&plan, &video, render, true, true).is_some());
+        let cam0 = crate::camera_layers::CameraLayerPlan { camera: 0, ..plan };
+        assert!(g.camera_layer_shadow(&cam0, &video, render, true, true).is_none());
+    }
+
     /// A turned Full Camera section from 1 s to 9 s: the plan carries the cover strength, full in
     /// the hold after the start and zero in the steady part.
     #[test]
@@ -7384,6 +7991,59 @@ mod tests {
         assert_eq!(cover_at(5.0), 0.0);
     }
 
+    /// A scene without layout regions plans no camera layers, and camera 0 lands exactly where
+    /// it did: the new (empty) keys change nothing.
+    #[test]
+    fn without_layout_regions_the_plan_has_no_camera_layers() {
+        let cfg = crate::config::all().pop().expect("cfg");
+        let before = plan_frame(&golden_input(&golden_scene(), &cfg));
+        let json = zoomed_golden_scene_json().replace(
+            r#""zoomRegions":[{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.3,"rotation":"none"}]"#,
+            r#""zoomRegions":[],"cameras":[],"cameraLayoutRegions":[]"#,
+        );
+        let scene = Scene::from_json(&json).expect("scene");
+        let after = plan_frame(&golden_input(&scene, &cfg));
+        assert!(before.camera_layers.is_empty());
+        assert!(after.camera_layers.is_empty());
+        assert_eq!(after.w_dst, before.w_dst);
+        assert_eq!(after.w_dst_prev, before.w_dst_prev);
+        assert_eq!(after.w_px, before.w_px);
+        assert_eq!(after.w_radius, before.w_radius);
+        assert_eq!(after.shape_fade, before.shape_fade);
+        assert_eq!(after.webcam, before.webcam);
+        assert_eq!(after.webcam_cover, before.webcam_cover);
+    }
+
+    /// Inside a layout region camera 0 is one of the planned layers, at the region's rect.
+    #[test]
+    fn with_a_layout_region_camera_0_comes_from_the_plan() {
+        let cfg = crate::config::all().pop().expect("cfg");
+        let json = zoomed_golden_scene_json().replace(
+            r#""zoomRegions":[{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.3,"rotation":"none"}]"#,
+            r#""zoomRegions":[],"cameraLayoutRegions":[{"clipIndex":0,"startSec":0.0,"endSec":4.0,"layers":[
+                {"camera":0,"rect":{"x":0.1,"y":0.2,"width":0.3,"height":0.4},"radiusFrac":0.1,"shape":"rectangle"}]}]"#,
+        );
+        let scene = Scene::from_json(&json).expect("scene");
+        // `golden_input` samples t = 1.5 s: past the lead-in, well before the lead-out.
+        let g = plan_frame(&golden_input(&scene, &cfg));
+        assert_eq!(g.camera_layers.len(), 1);
+        let cam0 = g.camera_layers[0];
+        assert_eq!(cam0.camera, 0);
+        assert_eq!(cam0.dst, [0.1, 0.2, 0.3, 0.4]);
+        assert_eq!(cam0.opacity, 1.0);
+        assert_eq!(cam0.shape, webcam_shape_code("rectangle"));
+        assert!(!cam0.fills_frame);
+        // Outside the region camera 0 is the default PiP, where `w_dst` puts it.
+        let outside = plan_frame(&FrameGeometryInput {
+            timeline_t_override: Some(6.0),
+            ..golden_input(&scene, &cfg)
+        });
+        assert_eq!(outside.camera_layers.len(), 1);
+        assert_eq!(outside.camera_layers[0].dst, outside.w_dst);
+        let r = outside.w_radius / outside.w_px[0].min(outside.w_px[1]).max(1.0);
+        assert_eq!(outside.camera_layers[0].radius_frac, r);
+    }
+
     /// The desk label's opacity at the compositor caller boundary, against the cover of the same
     /// frame plan: equal at every sampled frame, and the label (spanned over its whole section by
     /// the app) is on screen wherever the cover is not 0. Three sections: the review's 2.6 s one
@@ -7456,6 +8116,56 @@ mod tests {
         }
     }
 
+    /// A turned Full Camera section that meets a layout region: the cover follows the seam rule
+    /// (no hold before the layout region, only its own fade), and the label, spanned over the
+    /// whole section by the app, follows the cover there frame for frame without any seam
+    /// logic of its own.
+    #[test]
+    fn the_desk_label_follows_the_cover_across_a_seam_with_a_layout_region() {
+        use crate::regions::DESK_COVER_FADE_S;
+        use crate::text_anim::{annotation_text_state, DESK_COVER_ANIMATION};
+        let cfg = crate::config::all().pop().expect("cfg");
+        let zoom = r#""zoomRegions":[{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.3,"rotation":"none"}]"#;
+        let full = r#""zoomRegions":[],"cameraFullscreenRegions":[{"clipIndex":0,"startSec":1.0,"endSec":6.0,"rotation":180,"fullFrame":true}]"#;
+        let layout = r#","cameraLayoutRegions":[{"clipIndex":0,"startSec":6.0,"endSec":9.0,"layers":[
+                {"camera":0,"rect":{"x":0.1,"y":0.2,"width":0.3,"height":0.4},"radiusFrac":0.1,"shape":"rectangle"}]}]"#;
+        let json = zoomed_golden_scene_json();
+        let seam =
+            Scene::from_json(&json.replace(zoom, &format!("{full}{layout}"))).expect("scene");
+        let lone = Scene::from_json(&json.replace(zoom, full)).expect("scene");
+        let (start, end) = (1.0f32, 6.0f32);
+        let sample = |scene: &Scene, t: f32| {
+            let g = plan_frame(&FrameGeometryInput {
+                timeline_t_override: Some(t),
+                ..golden_input(scene, &cfg)
+            });
+            let label = annotation_text_state(
+                Some(DESK_COVER_ANIMATION),
+                (t - start) * 1000.0,
+                (end - start) * 1000.0,
+                g.webcam_cover,
+            );
+            (label.opacity, g.webcam_cover)
+        };
+        let mut t = start - 0.1;
+        while t < 9.1 {
+            let (label, cover) = sample(&seam, t);
+            assert_eq!(label, cover, "t = {t}");
+            if cover > 0.0 {
+                assert!(t >= start && t < end, "cover {cover} outside the label at {t}");
+            }
+            t += 1.0 / 120.0;
+        }
+        // Before the seam the cover (and so the label) is only its fade: half way up at
+        // end - fade/2 and sharp just before the fade, where a lone section still holds 1.
+        let (mid, _) = sample(&seam, end - DESK_COVER_FADE_S / 2.0);
+        assert!((mid - 0.5).abs() < 1e-3, "half way up at the seam: {mid}");
+        let before_fade = end - DESK_COVER_FADE_S - 0.05;
+        assert_eq!(sample(&seam, before_fade), (0.0, 0.0), "sharp before the seam's fade");
+        assert_eq!(sample(&lone, before_fade), (1.0, 1.0), "a lone section still holds");
+        assert!(sample(&seam, end - 0.001).0 > 0.99, "covered at the seam");
+    }
+
     /// Le pivot doit rester collé à `center` quand le sprite grandit — c'est exactement ce qui
     /// était cassé (ancrage centré en dur : la pointe s'éloignait proportionnellement à la
     /// taille). On dessine la même flèche à deux tailles et on vérifie que le point désigné
@@ -7865,6 +8575,7 @@ mod tests {
             shape_fade: 0.0,
             webcam: WebcamOrientation::default(),
             webcam_cover: 0.0,
+            camera_layers: Vec::new(),
             window_frame: None,
             screen_mask: None,
         }
@@ -9027,11 +9738,18 @@ mod tests {
                 )),
                 "blur_webcam_radius reads the texture size for its half-texel clamp"
             );
+            // `fs_main` only applies the layer's transparency to `fs_layer`, which draws it.
             let fs = module.entry_points.iter().find(|e| e.name == "fs_main").expect("fs_main");
+            let (body, f) = module
+                .functions
+                .iter()
+                .find(|(_, f)| f.name.as_deref() == Some("fs_layer"))
+                .expect("fs_layer exists");
+            assert_eq!(calls(&fs.function.body, body), 1, "fs_main draws through fs_layer");
             assert_eq!(
-                calls(&fs.function.body, kernel),
+                calls(&f.body, kernel),
                 1,
-                "fs_main blurs the covered camera once (LAYER_MODELS = {models})"
+                "fs_layer blurs the covered camera once (LAYER_MODELS = {models})"
             );
         }
     }
diff --git a/crates/compositor/src/gif_export.rs b/crates/compositor/src/gif_export.rs
index 8215704c2..7ab0c1b6c 100644
--- a/crates/compositor/src/gif_export.rs
+++ b/crates/compositor/src/gif_export.rs
@@ -256,6 +256,7 @@ fn export_gif_inner(
 
 		let mut screen_decs: HashMap<String, Decoder> = HashMap::new();
 		let mut webcam_decs: HashMap<String, Decoder> = HashMap::new();
+		let mut extra_decs: HashMap<String, Decoder> = HashMap::new();
 		screen_decs.insert(clips[0].screen.clone(), unsafe {
 			Decoder::open_for_export(&clips[0].screen, gpu)?
 		});
@@ -270,6 +271,7 @@ fn export_gif_inner(
 				&scene,
 				&mut screen_decs,
 				&mut webcam_decs,
+				&mut extra_decs,
 				&mut |frame_index| {
 					control.check()?;
 					// CPU readback of the staged RT (RGBA8 tightly-packed,
diff --git a/crates/compositor/src/lib.rs b/crates/compositor/src/lib.rs
index 767abac8a..67c233e4b 100644
--- a/crates/compositor/src/lib.rs
+++ b/crates/compositor/src/lib.rs
@@ -30,6 +30,7 @@
 pub mod audio;
 pub mod audio_jobs;
 pub mod camera;
+pub mod camera_layers;
 pub mod config;
 pub mod cursor;
 pub mod cursor_sdf;
@@ -56,6 +57,7 @@ pub mod shared_frames;
 pub mod text_anim;
 pub mod text_fonts;
 pub mod text_plate;
+pub(crate) mod extra_cameras;
 pub(crate) mod timeline_walk;
 
 // GPU backend : Windows → d3d_windows, macOS → d3d_macos. Ré-exporté sous le nom `d3d`
diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rs
index 8f56f22a2..d8e2c4e87 100644
--- a/crates/compositor/src/live.rs
+++ b/crates/compositor/src/live.rs
@@ -23,8 +23,9 @@
 //! le napi — le `gen` est l'identité de la frame (cf. `LatestFrame`).
 
 use crate::compositor::{Compositor, LiveParams};
+use crate::ffi::AVFrame;
 use crate::regions::{speed_at, ProgrammeClock};
-use crate::scene::Scene;
+use crate::scene::{Scene, SceneCameraLayoutRegion, SceneClipCamera};
 use crate::config::{self, Cfg};
 use crate::cursor::CursorTrack;
 use crate::d3d::{Backend, Gpu};
@@ -33,6 +34,10 @@ use crate::pipeline::Decoder;
 #[cfg(windows)]
 use crate::shared_frames::SharedRing;
 use crate::shared_frames::{SharedFrame, SlotBook};
+use crate::extra_cameras::{
+    camera_source_time, cameras_in_regions, extra_camera_active, extra_camera_keys, extra_frame_list,
+    has_camera_file, opened_or_skipped, seek_extra_camera, step_extra_camera, ExtraCameraKeys,
+};
 use crate::timeline_walk::{frame_step, FrameStep, NextFrameTime};
 use anyhow::Result;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
@@ -52,10 +57,6 @@ fn parse_hex_color(s: &str) -> Option<[f32; 4]> {
     Some([r, g, b, 1.0])
 }
 
-fn webcam_seek_time(screen_source_time_sec: f64, webcam_offset_sec: f64) -> f64 {
-    (screen_source_time_sec - webcam_offset_sec).max(0.0)
-}
-
 /// Décodeurs déjà ouverts ET positionnés au bon playhead pour un clip à venir — le résultat
 /// d'un préchargement en tâche de fond (voir `open_and_seek_clip`/`maybe_start_prefetch`
 /// dans `render_thread`). Appliquer ceci à un `Player` (`apply_prefetched`) ne fait plus
@@ -72,6 +73,9 @@ struct PrefetchedClip {
     /// des paires ouvertes plusieurs bascules plus tôt. Cf. `open_webcam_or_stand_in`.
     webcam_decoder_is_real: bool,
     webcam_offset_sec: f64,
+    /// The clip's extra cameras (index k-1 = camera k) and what they were opened for.
+    extra: Vec<Option<ExtraCamera>>,
+    extra_keys: ExtraCameraKeys,
     idx: u32,
     /// Piste curseur du clip à venir, préchargée ici pour la même raison que les décodeurs :
     /// sans ça, la bascule à la frontière restait synchrone sur CE point précis (lecture +
@@ -149,18 +153,122 @@ fn should_draw_webcam(webcam_path: &str, screen_path: &str, decoder_is_real: boo
     webcam_is_real(webcam_path, screen_path) && decoder_is_real
 }
 
+/// An extra camera (k >= 1) of the active clip, decoded only near the layout regions that show
+/// it (`extra_camera_active`).
+struct ExtraCamera {
+    dec: Decoder,
+    offset_sec: f64,
+    /// The last step or seek left a frame to draw. Read by `Player::recompose`.
+    shown: bool,
+    /// Camera source time past which the file has no frame left (`step_extra_camera`).
+    ended_at: Option<f64>,
+}
+
+impl ExtraCamera {
+    /// `step_extra_camera` toward `target` (camera source time).
+    unsafe fn step_to(&mut self, target: f64) -> Result<*const AVFrame> {
+        let frame = step_extra_camera(&mut self.dec, &mut self.ended_at, target)?;
+        self.shown = !frame.is_null();
+        Ok(frame)
+    }
+
+    /// `seek_extra_camera` to `target` (camera source time).
+    unsafe fn seek(&mut self, target: f64) -> Result<*const AVFrame> {
+        let frame = seek_extra_camera(&mut self.dec, &mut self.ended_at, target)?;
+        self.shown = !frame.is_null();
+        Ok(frame)
+    }
+}
+
+/// The extra cameras clip `clip_index` opens: those its own layout regions
+/// (`Scene::for_clip_window`) draw and that the clip has a file for.
+fn extra_cameras_for_clip(scene: &Scene, clip_index: usize) -> Vec<usize> {
+    let Some(clip) = scene.clips.get(clip_index) else {
+        return Vec::new();
+    };
+    // The common case — no layout region anywhere — skips the windowing copy of the scene.
+    if scene.camera_layout_regions.is_empty() || clip.additional_cameras.is_empty() {
+        return Vec::new();
+    }
+    cameras_in_regions(&scene_for_clip(scene, clip_index).camera_layout_regions)
+        .into_iter()
+        .filter(|&k| has_camera_file(clip.additional_cameras.get(k - 1)))
+        .collect()
+}
+
+/// `extra_camera_keys` for clip `clip_index` of `scene`, from the clip's own camera files.
+fn scene_extra_camera_keys(scene: &Scene, clip_index: usize) -> ExtraCameraKeys {
+    let sources = scene.clips.get(clip_index).map(|c| c.additional_cameras.as_slice()).unwrap_or(&[]);
+    extra_camera_keys(&extra_cameras_for_clip(scene, clip_index), sources)
+}
+
+/// The windowed layout regions of clip `clip_index` (what `camera_layers_at` plans from).
+fn clip_layout_regions(scene: &Scene, clip_index: usize) -> Vec<SceneCameraLayoutRegion> {
+    if scene.camera_layout_regions.is_empty() {
+        return Vec::new();
+    }
+    scene_for_clip(scene, clip_index).camera_layout_regions
+}
+
+fn same_extra_key(a: &Option<SceneClipCamera>, b: &Option<SceneClipCamera>) -> bool {
+    match (a, b) {
+        (None, None) => true,
+        (Some(a), Some(b)) => a.path == b.path && (a.offset_sec - b.offset_sec).abs() < 1e-9,
+        _ => false,
+    }
+}
+
+fn same_extra_keys(a: &[Option<SceneClipCamera>], b: &[Option<SceneClipCamera>]) -> bool {
+    a.len() == b.len() && a.iter().zip(b).all(|(a, b)| same_extra_key(a, b))
+}
+
+/// Same spans and same cameras in each: what decides when an extra camera is active
+/// (`extra_camera_active`). Rects and shapes do not matter to the decoders.
+fn same_region_timing(a: &[SceneCameraLayoutRegion], b: &[SceneCameraLayoutRegion]) -> bool {
+    a.len() == b.len()
+        && a.iter().zip(b).all(|(a, b)| {
+            a.clip_index == b.clip_index
+                && a.start_sec == b.start_sec
+                && a.end_sec == b.end_sec
+                && a.layers.len() == b.layers.len()
+                && a.layers.iter().zip(&b.layers).all(|(x, y)| x.camera == y.camera)
+        })
+}
+
+/// Whether `set_extra_cameras` seeks the extra cameras right away. Playing on (`steady`:
+/// playing, and the screen position did not jump) with the same files and the same region
+/// timing, the next playback step (`advance_extras(.., false)`) moves them on: seeking every
+/// camera on each scene push would stall the preview while it plays.
+fn extras_need_seek(keys_changed: bool, timing_changed: bool, steady: bool) -> bool {
+    keys_changed || timing_changed || !steady
+}
+
+/// Opens the extra cameras `keys` asks for, without seeking them: they are positioned when
+/// they become active (`Player::advance_extras`).
+unsafe fn open_extra_cameras(keys: &[Option<SceneClipCamera>], gpu: &Gpu) -> Vec<Option<ExtraCamera>> {
+    keys.iter()
+        .map(|key| {
+            let key = key.as_ref()?;
+            let dec = opened_or_skipped(&key.path, Decoder::open(&key.path, gpu))?;
+            Some(ExtraCamera { dec, offset_sec: key.offset_sec, shown: false, ended_at: None })
+        })
+        .collect()
+}
+
 unsafe fn open_and_seek_clip(
     screen_path: &str,
     webcam_path: &str,
     webcam_offset_sec: f64,
+    extra_keys: &[Option<SceneClipCamera>],
     source_time_sec: f64,
     gpu: &Gpu,
 ) -> Result<PrefetchedClip> {
     let source_time_sec = source_time_sec.max(0.0);
     let mut sdec = Decoder::open(screen_path, gpu)?;
     let (mut wdec, webcam_decoder_is_real) = open_webcam_or_stand_in(screen_path, webcam_path, gpu)?;
+    let extra = open_extra_cameras(extra_keys, gpu);
     let sf = sdec.seek_to_or_last(source_time_sec)?;
-    if webcam_decoder_is_real && wdec.seek_to(webcam_seek_time(source_time_sec, webcam_offset_sec))?.is_null() {
+    if webcam_decoder_is_real && wdec.seek_to(camera_source_time(source_time_sec, webcam_offset_sec))?.is_null() {
         wdec.seek_to(0.0)?;
     }
     if sf.is_null() {
@@ -168,7 +276,16 @@ unsafe fn open_and_seek_clip(
     }
     let idx = (source_time_sec * sdec.fps()).round().max(0.0) as u32;
     let cursor_track = CursorTrack::load(&format!("{screen_path}.cursor.json"), 0.0, 24.0 * 3600.0).ok();
-    Ok(PrefetchedClip { sdec, wdec, webcam_decoder_is_real, webcam_offset_sec, idx, cursor_track })
+    Ok(PrefetchedClip {
+        sdec,
+        wdec,
+        webcam_decoder_is_real,
+        webcam_offset_sec,
+        extra,
+        extra_keys: extra_keys.to_vec(),
+        idx,
+        cursor_track,
+    })
 }
 
 /// Nombre de paires de décodeurs INACTIVES gardées ouvertes en plus de la paire active.
@@ -180,11 +297,29 @@ unsafe fn open_and_seek_clip(
 /// les timelines 2-4 clips, à baisser si la VRAM serre.
 const DECODER_POOL_CAP: usize = 3;
 
-/// Une paire de décodeurs mise de côté, prête à être réactivée sans réouverture.
-struct PooledClip {
+/// What a set of open decoders was opened for: the screen, camera 0 and the extra cameras.
+/// A pooled set is reused only for the same key, extra cameras included — a pooled pair
+/// opened without camera 2 must not stand in for a clip whose layout shows it.
+#[derive(Clone)]
+struct ClipKey {
     screen_path: String,
     webcam_path: String,
     webcam_offset_sec: f64,
+    extras: ExtraCameraKeys,
+}
+
+impl ClipKey {
+    fn matches(&self, other: &ClipKey) -> bool {
+        self.screen_path == other.screen_path
+            && self.webcam_path == other.webcam_path
+            && (self.webcam_offset_sec - other.webcam_offset_sec).abs() < 1e-9
+            && same_extra_keys(&self.extras, &other.extras)
+    }
+}
+
+/// Une paire de décodeurs mise de côté, prête à être réactivée sans réouverture.
+struct PooledClip {
+    key: ClipKey,
     clip: PrefetchedClip,
 }
 
@@ -207,7 +342,7 @@ unsafe fn seek_pair(
     if !webcam_decoder_is_real {
         return Ok(true);
     }
-    let mut wf = wdec.seek_to(webcam_seek_time(source_time_sec, webcam_offset_sec))?;
+    let mut wf = wdec.seek_to(camera_source_time(source_time_sec, webcam_offset_sec))?;
     if wf.is_null() {
         wf = wdec.seek_to(0.0)?;
     }
@@ -226,21 +361,15 @@ unsafe fn seek_pair(
 unsafe fn swap_clip_pooled(
     player: &mut Player,
     pool: &mut Vec<PooledClip>,
-    request: &ActiveClipRequest,
-    active_screen: &str,
-    active_webcam: &str,
-    active_webcam_offset_sec: f64,
+    request: &ClipKey,
+    source_time_sec: f64,
+    active: &ClipKey,
 ) -> Result<()> {
     let timing = std::env::var("OPENSCREEN_CLIPSWITCH_TIMING").is_ok();
     let t0 = std::time::Instant::now();
-    let t = request.source_time_sec.max(0.0);
-    let matches = |p: &PooledClip| {
-        p.screen_path == request.screen_path
-            && p.webcam_path == request.webcam_path
-            && (p.webcam_offset_sec - request.webcam_offset_sec).abs() < 1e-9
-    };
+    let t = source_time_sec.max(0.0);
     let mut hit = false;
-    let incoming: PrefetchedClip = match pool.iter().position(&matches) {
+    let incoming: PrefetchedClip = match pool.iter().position(|p| p.key.matches(request)) {
         Some(i) => {
             let mut pooled = pool.remove(i);
             // Reseek les décodeurs poolés AVANT de les installer. Échec → on les jette et on
@@ -257,25 +386,16 @@ unsafe fn swap_clip_pooled(
                 pooled.clip
             } else {
                 drop(pooled);
-                player.open_clip(&request.screen_path, &request.webcam_path, request.webcam_offset_sec, t)?
+                player.open_clip(request, t)?
             }
         }
-        None => player.open_clip(&request.screen_path, &request.webcam_path, request.webcam_offset_sec, t)?,
+        None => player.open_clip(request, t)?,
     };
     let outgoing = player.swap_active(incoming);
     // Met la paire quittée en pool : dédup par clé (jamais deux entrées d'un même média), puis
     // éviction LRU (le plus ancien, en tête, part en premier).
-    pool.retain(|p| {
-        !(p.screen_path == active_screen
-            && p.webcam_path == active_webcam
-            && (p.webcam_offset_sec - active_webcam_offset_sec).abs() < 1e-9)
-    });
-    pool.push(PooledClip {
-        screen_path: active_screen.to_string(),
-        webcam_path: active_webcam.to_string(),
-        webcam_offset_sec: active_webcam_offset_sec,
-        clip: outgoing,
-    });
+    pool.retain(|p| !p.key.matches(active));
+    pool.push(PooledClip { key: active.clone(), clip: outgoing });
     while pool.len() > DECODER_POOL_CAP {
         pool.remove(0);
     }
@@ -302,6 +422,12 @@ pub struct Player {
     /// (`swap_active`), lu par la boucle de rendu pour décider de dessiner la vignette.
     webcam_decoder_is_real: bool,
     webcam_offset_sec: f64,
+    /// The active clip's extra cameras (index k-1 = camera k), what they were opened for, and
+    /// the clip's windowed layout regions that decide when each one is decoded. All empty
+    /// without layout regions: no decoder, nothing to advance.
+    extra: Vec<Option<ExtraCamera>>,
+    extra_keys: ExtraCameraKeys,
+    camera_regions: Vec<SceneCameraLayoutRegion>,
     has_current_frame: bool,
     use_current_on_next_step: bool,
     idx: u32,
@@ -324,6 +450,9 @@ impl Player {
             },
             webcam_decoder_is_real,
             webcam_offset_sec: 0.0,
+            extra: Vec::new(),
+            extra_keys: Vec::new(),
+            camera_regions: Vec::new(),
             has_current_frame: false,
             use_current_on_next_step: false,
             idx: 0,
@@ -342,10 +471,17 @@ impl Player {
         screen_path: &str,
         webcam_path: &str,
         webcam_offset_sec: f64,
+        extra_keys: &[Option<SceneClipCamera>],
         source_time_sec: f64,
     ) -> Result<()> {
-        let prefetched =
-            open_and_seek_clip(screen_path, webcam_path, webcam_offset_sec, source_time_sec, &self.gpu)?;
+        let prefetched = open_and_seek_clip(
+            screen_path,
+            webcam_path,
+            webcam_offset_sec,
+            extra_keys,
+            source_time_sec,
+            &self.gpu,
+        )?;
         self.apply_prefetched(prefetched);
         Ok(())
     }
@@ -412,6 +548,8 @@ impl Player {
             // recalculer), l'entrante impose la sienne au player.
             webcam_decoder_is_real: self.webcam_decoder_is_real,
             webcam_offset_sec: self.webcam_offset_sec,
+            extra: std::mem::replace(&mut self.extra, incoming.extra),
+            extra_keys: std::mem::replace(&mut self.extra_keys, incoming.extra_keys),
             idx: self.idx,
             // Le curseur est re-dérivé du chemin à la réactivation ; inutile de le trimballer.
             cursor_track: None,
@@ -426,14 +564,107 @@ impl Player {
 
     /// Ouvre une nouvelle paire de décodeurs positionnée à `source_time_sec`, SANS l'installer
     /// (l'appelant l'échange via `swap_active`). Réutilise le device D3D11 du player.
-    unsafe fn open_clip(
-        &self,
-        screen: &str,
-        webcam: &str,
-        webcam_offset_sec: f64,
-        source_time_sec: f64,
-    ) -> Result<PrefetchedClip> {
-        open_and_seek_clip(screen, webcam, webcam_offset_sec, source_time_sec, &self.gpu)
+    unsafe fn open_clip(&self, key: &ClipKey, source_time_sec: f64) -> Result<PrefetchedClip> {
+        open_and_seek_clip(
+            &key.screen_path,
+            &key.webcam_path,
+            key.webcam_offset_sec,
+            &key.extras,
+            source_time_sec,
+            &self.gpu,
+        )
+    }
+
+    /// What the active extra cameras were opened for (the extra half of the pool key).
+    fn extra_keys(&self) -> &[Option<SceneClipCamera>] {
+        &self.extra_keys
+    }
+
+    /// Installs the active clip's windowed layout regions and the extra cameras they need
+    /// (`keys`): slots whose key is unchanged keep their decoder, the others are closed and
+    /// (re)opened — a file that will not open leaves its slot empty, once. Then positions every
+    /// camera that is near one of its regions at the current screen time, so a paused
+    /// recompose shows it at once — unless nothing that matters to the decoders changed while
+    /// playback goes on (`steady`, see `extras_need_seek`). `true` when a decoder was closed:
+    /// the caller must then clear the compositor's SRV cache (which also forgets the extra
+    /// frame pointers).
+    pub(crate) unsafe fn set_extra_cameras(
+        &mut self,
+        regions: Vec<SceneCameraLayoutRegion>,
+        keys: ExtraCameraKeys,
+        steady: bool,
+    ) -> bool {
+        let timing_changed = !same_region_timing(&self.camera_regions, &regions);
+        let keys_changed = !same_extra_keys(&self.extra_keys, &keys);
+        self.camera_regions = regions;
+        let mut closed = false;
+        if keys_changed {
+            let mut old = std::mem::take(&mut self.extra);
+            let mut extra = Vec::with_capacity(keys.len());
+            for (k, key) in keys.iter().enumerate() {
+                let old_cam = old.get_mut(k).and_then(Option::take);
+                let old_key = self.extra_keys.get(k).cloned().flatten();
+                if same_extra_key(&old_key, key) {
+                    extra.push(old_cam);
+                    continue;
+                }
+                closed |= old_cam.is_some();
+                drop(old_cam);
+                extra.extend(open_extra_cameras(std::slice::from_ref(key), &self.gpu));
+            }
+            closed |= old.iter().any(Option::is_some);
+            self.extra = extra;
+            self.extra_keys = keys;
+        }
+        if !extras_need_seek(keys_changed, timing_changed, steady) {
+            return closed;
+        }
+        let t = self.sdec.cur_time_sec();
+        closed | self.advance_extras(t, true).1
+    }
+
+    /// The extra cameras' frames at screen source time `screen_t`, each camera stepped
+    /// (`seek == false`) or sought toward its own source time only while it is near one of
+    /// its regions; an idle camera is left alone and gives null. A camera whose decoder fails
+    /// is closed with one warning — its layer disappears, the preview goes on. The `bool` says
+    /// a decoder was closed (see `set_extra_cameras`).
+    unsafe fn advance_extras(&mut self, screen_t: f64, seek: bool) -> (Vec<*const AVFrame>, bool) {
+        let mut closed = false;
+        let mut frames = Vec::with_capacity(self.extra.len());
+        for (k, slot) in self.extra.iter_mut().enumerate() {
+            let camera = k + 1;
+            let frame = match slot {
+                Some(cam) if extra_camera_active(&self.camera_regions, camera, screen_t) => {
+                    let target = camera_source_time(screen_t, cam.offset_sec);
+                    let result = if seek { cam.seek(target) } else { cam.step_to(target) };
+                    match result {
+                        Ok(frame) => frame,
+                        Err(e) => {
+                            eprintln!("WARNING: extra camera {camera} stopped decoding: {e:#}. Its layer will not be drawn.");
+                            *slot = None;
+                            closed = true;
+                            std::ptr::null()
+                        }
+                    }
+                }
+                Some(cam) => {
+                    cam.shown = false;
+                    std::ptr::null()
+                }
+                None => std::ptr::null(),
+            };
+            frames.push(frame);
+        }
+        (frames, closed)
+    }
+
+    /// Hands the extra cameras' frames to `comp` for the next `compose_frame`. Called before
+    /// every compose: the compositor keeps the pointers until the next call.
+    unsafe fn hand_extra_frames(comp: &Compositor, frames: &[*const AVFrame], closed: bool) {
+        if closed {
+            comp.clear_srv_cache();
+        }
+        comp.set_extra_camera_frames(frames);
     }
 
     /// Le décodeur webcam ACTIF est-il la vraie caméra ? `false` quand c'est le remplaçant
@@ -600,6 +831,8 @@ impl Player {
 
         self.has_current_frame = true;
         self.sync_time(comp);
+        let (extra, closed) = self.advance_extras(self.sdec.cur_time_sec(), false);
+        Self::hand_extra_frames(comp, &extra, closed);
         comp.compose_frame(sf, wf, self.idx as f32, cfg)?;
         self.idx = self.idx.wrapping_add(1);
         Ok(true)
@@ -630,6 +863,10 @@ impl Player {
             return Ok(false);
         }
         self.sync_time(comp);
+        let extra = extra_frame_list(&self.extra, |cam| {
+            if cam.shown { cam.dec.cur_frame() as *const AVFrame } else { std::ptr::null() }
+        });
+        comp.set_extra_camera_frames(&extra);
         let f = self.idx.saturating_sub(1);
         comp.compose_frame(sf, wf, f as f32, cfg)?;
         Ok(true)
@@ -646,7 +883,7 @@ impl Player {
         // ne serait pas composée. Sans caméra, la frame écran tient sa place.
         let wf = if self.webcam_decoder_is_real {
             self.wdec
-                .seek_to_or_last(webcam_seek_time(target_sec, self.webcam_offset_sec))?
+                .seek_to_or_last(camera_source_time(target_sec, self.webcam_offset_sec))?
         } else {
             sf
         };
@@ -660,6 +897,8 @@ impl Player {
         // "idx" ne sert plus qu'au fallback fixture (jamais lu si une scène est posée) — dérivé
         // du temps réel pour rester cohérent si jamais consulté.
         self.idx = (target_sec * self.sdec.fps()).round().max(0.0) as u32;
+        let (extra, closed) = self.advance_extras(target_sec, true);
+        Self::hand_extra_frames(comp, &extra, closed);
         comp.compose_frame(sf, wf, self.idx as f32, cfg)?;
         Ok(true)
     }
@@ -738,6 +977,9 @@ struct ActiveClipRequest {
     screen_path: String,
     webcam_path: String,
     webcam_offset_sec: f64,
+    /// Cameras 2-4 of the clip (index k-1 = camera k); which of them open is decided by the
+    /// clip's layout regions (`extra_cameras_for_clip`).
+    additional_cameras: Vec<SceneClipCamera>,
     /// Identité dans le flux `Scene.clips` trié (les chemins ne suffisent pas pour un asset partagé).
     clip_index: usize,
     /// Playhead exprimé sur l'horloge source écran du nouveau clip.
@@ -1134,6 +1376,7 @@ impl LiveView {
         screen_path: &str,
         webcam_path: &str,
         webcam_offset_sec: f64,
+        additional_cameras: Vec<SceneClipCamera>,
         clip_index: usize,
         source_time_sec: f64,
     ) {
@@ -1142,6 +1385,7 @@ impl LiveView {
                 screen_path: screen_path.to_string(),
                 webcam_path: webcam_path.to_string(),
                 webcam_offset_sec,
+                additional_cameras,
                 clip_index,
                 source_time_sec: source_time_sec.max(0.0),
             });
@@ -1240,7 +1484,7 @@ type PendingPrefetch = (usize, std::sync::mpsc::Receiver<Result<PrefetchedClip>>
 /// tâche de fond. Assez large pour couvrir un `Decoder::open` typique (ouverture fichier +
 /// `avformat_find_stream_info` + init D3D11VA), assez court pour ne pas garder deux paires de
 /// décodeurs ouvertes plus longtemps que nécessaire.
-const PREFETCH_LEAD_SEC: f64 = 0.75;
+pub(crate) const PREFETCH_LEAD_SEC: f64 = 0.75;
 
 /// Durée pendant laquelle la boucle continue de recomposer après un changement en pause, le
 /// temps qu'un effet asynchrone (segmentation webcam) livre son résultat. Généreuse : à
@@ -1294,6 +1538,7 @@ unsafe fn maybe_start_prefetch(
         0
     };
     let next_clip = scene.clips[next_index].clone();
+    let extra_keys = scene_extra_camera_keys(scene, next_index);
     // Copie légère (COM refcount, pas de nouveau device) — même motif que `Player::open`.
     let gpu_clone = Gpu {
         device: gpu.device.clone(),
@@ -1308,6 +1553,7 @@ unsafe fn maybe_start_prefetch(
                 &next_clip.screen_path,
                 &next_clip.webcam_path,
                 next_clip.webcam_offset_sec,
+                &extra_keys,
                 next_clip.source_start_sec,
                 &gpu_clone,
             )
@@ -1345,6 +1591,7 @@ unsafe fn advance_to_next_scene_clip(
     active_screen_path: &mut String,
     active_webcam_path: &mut String,
     active_webcam_offset_sec: &mut f64,
+    active_additional_cameras: &mut Vec<SceneClipCamera>,
     active_clip_index: &mut usize,
     raw_cursor: &mut Option<CursorTrack>,
     loaded_cursor_path: &mut String,
@@ -1359,6 +1606,7 @@ unsafe fn advance_to_next_scene_clip(
         0
     };
     let next_clip = &scene.clips[next_index];
+    let extra_keys = scene_extra_camera_keys(scene, next_index);
 
     // N'importe quel préchargement en cours ne concerne plus que CETTE frontière (on vient
     // de la franchir, bien ou mal ciblée) — on le consomme s'il correspond, on l'abandonne
@@ -1386,6 +1634,7 @@ unsafe fn advance_to_next_scene_clip(
                 &next_clip.screen_path,
                 &next_clip.webcam_path,
                 next_clip.webcam_offset_sec,
+                &extra_keys,
                 next_clip.source_start_sec,
             )
         }
@@ -1393,6 +1642,7 @@ unsafe fn advance_to_next_scene_clip(
             &next_clip.screen_path,
             &next_clip.webcam_path,
             next_clip.webcam_offset_sec,
+            &extra_keys,
             next_clip.source_start_sec,
         ),
     };
@@ -1404,12 +1654,18 @@ unsafe fn advance_to_next_scene_clip(
             // sur l'adresse de la texture, et garder des entrées d'un décodeur fermé fait
             // fuir de la VRAM puis, en cas de réutilisation d'adresse, rendre l'image du clip
             // précédent.
+            let windowed = scene_for_clip(scene, next_index);
+            // The prefetch opened exactly these keys, so this only installs the regions and
+            // positions the cameras; the cache is cleared right below in any case.
+            // The screen position jumped to the next clip: always position the cameras.
+            player.set_extra_cameras(windowed.camera_layout_regions.clone(), extra_keys, false);
             comp.clear_srv_cache();
             *active_screen_path = next_clip.screen_path.clone();
             *active_webcam_path = next_clip.webcam_path.clone();
             *active_webcam_offset_sec = next_clip.webcam_offset_sec;
+            *active_additional_cameras = next_clip.additional_cameras.clone();
             *active_clip_index = next_index;
-            comp.set_scene(Some(scene_for_clip(scene, *active_clip_index)));
+            comp.set_scene(Some(windowed));
             player.set_programme_clock(Some(scene), *active_clip_index);
             // Réutilise le curseur préchargé s'il est disponible (voir plus haut) — sinon
             // (préchargement pas encore prêt / raté) on retombe sur la lecture synchrone
@@ -1487,6 +1743,9 @@ unsafe fn render_thread(
     let mut active_screen_path = screen.to_string();
     let mut active_webcam_path = webcam.to_string();
     let mut active_webcam_offset_sec = 0.0f64;
+    // Cameras 2-4 of the active clip, as the app (`set_active_clip`) or the scene (auto-advance)
+    // gave them. The view starts without: `create_view` carries camera 0 only.
+    let mut active_additional_cameras: Vec<SceneClipCamera> = Vec::new();
     let mut active_clip_index = 0usize;
     // Copie de la Scene complète (tous les clips), tenue à jour à chaque push de l'app —
     // permet à la boucle de lecture libre de connaître la fenêtre source
@@ -1567,6 +1826,26 @@ unsafe fn render_thread(
             // JAMAIS fatal : on retombe sur l'ouverture complète, chemin connu comme sûr.
             // L'optimisation ne s'applique donc que là où elle fonctionne démontrablement.
             let repositioned = same_media && matches!(player.seek_active(request.source_time_sec), Ok(true));
+            // The extra cameras this clip's layout regions show, from the files the request
+            // carries. Resolved against the scene before the switch so that the pool and the
+            // fresh open both see the full key.
+            let request_scene = shared.scene.lock().unwrap().clone();
+            let request_clip_index = request_scene.as_ref().and_then(|scene| {
+                resolve_scene_clip_index(
+                    scene,
+                    request.clip_index,
+                    &request.screen_path,
+                    &request.webcam_path,
+                    request.webcam_offset_sec,
+                )
+            });
+            let request_extras = match (&request_scene, request_clip_index) {
+                (Some(scene), Some(index)) => extra_camera_keys(
+                    &extra_cameras_for_clip(scene, index),
+                    &request.additional_cameras,
+                ),
+                _ => Vec::new(),
+            };
             let switch_result = if repositioned {
                 Ok(())
             } else {
@@ -1574,13 +1853,24 @@ unsafe fn render_thread(
                 // ouverte si possible (reseek au lieu de rouvrir) et met en pool celle qu'on
                 // quitte, au lieu du couple ouvrir-puis-fermer. Voir `swap_clip_pooled` et la
                 // mesure de ~120 ms/franchissement qui l'a motivé.
+                let incoming = ClipKey {
+                    screen_path: request.screen_path.clone(),
+                    webcam_path: request.webcam_path.clone(),
+                    webcam_offset_sec: request.webcam_offset_sec,
+                    extras: request_extras.clone(),
+                };
+                let active = ClipKey {
+                    screen_path: active_screen_path.clone(),
+                    webcam_path: active_webcam_path.clone(),
+                    webcam_offset_sec: active_webcam_offset_sec,
+                    extras: player.extra_keys().to_vec(),
+                };
                 swap_clip_pooled(
                     &mut player,
                     &mut decoder_pool,
-                    &request,
-                    &active_screen_path,
-                    &active_webcam_path,
-                    active_webcam_offset_sec,
+                    &incoming,
+                    request.source_time_sec,
+                    &active,
                 )
             };
             match switch_result {
@@ -1602,8 +1892,18 @@ unsafe fn render_thread(
                     active_screen_path = request.screen_path;
                     active_webcam_path = request.webcam_path;
                     active_webcam_offset_sec = request.webcam_offset_sec;
-                    let scene = shared.scene.lock().unwrap().clone();
+                    active_additional_cameras = request.additional_cameras;
+                    let scene = request_scene;
                     full_scene = scene.clone();
+                    // No scene clip for the request → no layout regions (and no extras).
+                    let regions = match (&scene, request_clip_index) {
+                        (Some(s), Some(index)) => clip_layout_regions(s, index),
+                        _ => Vec::new(),
+                    };
+                    // A clip request moves the screen position: position the cameras.
+                    if player.set_extra_cameras(regions, request_extras, false) {
+                        comp.clear_srv_cache();
+                    }
                     if let Some(base_scene) = scene {
                         if let Some(index) = resolve_scene_clip_index(
                             &base_scene,
@@ -1709,6 +2009,7 @@ unsafe fn render_thread(
             prefetch = None;
             let scene = shared.scene.lock().unwrap().clone();
             full_scene = scene.clone();
+            let mut clip_resolved = false;
             let scene = scene.map(|base_scene| {
                 scene_applied = true;
                 if let Some(index) = resolve_scene_clip_index(
@@ -1719,9 +2020,35 @@ unsafe fn render_thread(
                     active_webcam_offset_sec,
                 ) {
                     active_clip_index = index;
+                    clip_resolved = true;
                 }
                 scene_for_clip(&base_scene, active_clip_index)
             });
+            // The resolved scene clip's own camera files win over the last clip request's: an
+            // offset or file edited mid-clip arrives with the scene, not with a new request.
+            if clip_resolved {
+                if let Some(clip) = full_scene.as_ref().and_then(|s| s.clips.get(active_clip_index)) {
+                    active_additional_cameras = clip.additional_cameras.clone();
+                }
+            }
+            // A new scene can add, move or drop the layout regions that show an extra camera:
+            // open what the active clip now shows, close what it no longer does.
+            let (regions, keys) = match (&full_scene, &scene) {
+                (Some(full), Some(windowed)) => (
+                    windowed.camera_layout_regions.clone(),
+                    extra_camera_keys(
+                        &extra_cameras_for_clip(full, active_clip_index),
+                        &active_additional_cameras,
+                    ),
+                ),
+                _ => (Vec::new(), Vec::new()),
+            };
+            // A scene push leaves the screen position where it is: while playing, unchanged
+            // cameras are stepped by playback instead of sought again.
+            let steady = shared.playing.load(Ordering::Relaxed);
+            if player.set_extra_cameras(regions, keys, steady) {
+                comp.clear_srv_cache();
+            }
             comp.set_scene(scene);
         }
         // Le temps programme dépend du clip actif ET de la scène entière (durées des clips
@@ -1836,6 +2163,7 @@ unsafe fn render_thread(
                                 &mut active_screen_path,
                                 &mut active_webcam_path,
                                 &mut active_webcam_offset_sec,
+                                &mut active_additional_cameras,
                                 &mut active_clip_index,
                                 &mut raw_cursor,
                                 &mut loaded_cursor_path,
@@ -1864,6 +2192,7 @@ unsafe fn render_thread(
                             &mut active_screen_path,
                             &mut active_webcam_path,
                             &mut active_webcam_offset_sec,
+                            &mut active_additional_cameras,
                             &mut active_clip_index,
                             &mut raw_cursor,
                             &mut loaded_cursor_path,
@@ -2323,8 +2652,147 @@ mod tests {
 
     #[test]
     fn webcam_seek_uses_screen_source_time_and_offset() {
-        assert_eq!(webcam_seek_time(22.5, 1.25), 21.25);
-        assert_eq!(webcam_seek_time(0.5, 1.25), 0.0);
+        assert_eq!(camera_source_time(22.5, 1.25), 21.25);
+        assert_eq!(camera_source_time(0.5, 1.25), 0.0);
+    }
+
+    // --- extra cameras (2-4) ----------------------------------------------------
+
+    /// Two clips: clip 0 has files for cameras 1 and 3 (camera 2's slot is empty), clip 1 for
+    /// camera 1 only. Layout regions: clip 0 shows cameras 1 and 2 on 2-5 s and camera 3 only
+    /// in an empty region; clip 1 shows camera 1 on 21-22 s.
+    fn layout_scene() -> Scene {
+        let layer = |camera: usize| {
+            format!(r#"{{"camera":{camera},"rect":{{"x":0,"y":0,"width":0.5,"height":0.5}},"radiusFrac":0,"shape":"rectangle","fillsFrame":false}}"#)
+        };
+        let json = format!(
+            r##"{{
+            "clips": [
+                {{"screenPath":"/s0.mp4","webcamPath":"/w0.mp4","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":true,
+                  "additionalCameras":[{{"path":"/c1.mp4","offsetSec":0.5}},{{"path":"","offsetSec":0}},{{"path":"/c3.mp4","offsetSec":0}}]}},
+                {{"screenPath":"/s1.mp4","webcamPath":"/w1.mp4","sourceStartSec":20,"sourceEndSec":30,"webcamOffsetSec":0,"hasAudio":true,
+                  "additionalCameras":[{{"path":"/d1.mp4","offsetSec":0}}]}}
+            ],
+            "layout":{{"preset":"picture-in-picture","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},
+            "effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0}},
+            "background":{{"kind":"color","color":"#000000"}},
+            "zoomRegions":[],
+            "cameraLayoutRegions":[
+                {{"clipIndex":0,"startSec":2,"endSec":5,"layers":[{l0},{l1},{l2}]}},
+                {{"clipIndex":0,"startSec":7,"endSec":7,"layers":[{l3}]}},
+                {{"clipIndex":1,"startSec":21,"endSec":22,"layers":[{l1}]}}
+            ],
+            "cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
+            "cropByClip":[null,null],
+            "output":{{"width":1920,"height":1080,"fps":30}}
+        }}"##,
+            l0 = layer(0),
+            l1 = layer(1),
+            l2 = layer(2),
+            l3 = layer(3),
+        );
+        Scene::from_json(&json).expect("layout scene")
+    }
+
+    fn camera(path: &str, offset_sec: f64) -> SceneClipCamera {
+        SceneClipCamera { path: path.to_string(), offset_sec }
+    }
+
+    #[test]
+    fn extra_cameras_to_open_are_those_the_clips_regions_reference() {
+        let scene = layout_scene();
+        // Camera 2 is shown but clip 0 has no file for it; camera 3 has a file but only an
+        // empty region; camera 0 is not an extra camera.
+        assert_eq!(extra_cameras_for_clip(&scene, 0), vec![1]);
+        // Clip 1 only sees its own region.
+        assert_eq!(extra_cameras_for_clip(&scene, 1), vec![1]);
+        assert!(extra_cameras_for_clip(&scene, 9).is_empty());
+        // No layout region at all: nothing to open, whatever files the clip has.
+        assert!(extra_cameras_for_clip(&multiclip_scene(), 0).is_empty());
+
+        let keys = scene_extra_camera_keys(&scene, 0);
+        assert_eq!(keys.len(), 1, "trailing empty slots are dropped");
+        let first = keys[0].as_ref().expect("camera 1");
+        assert_eq!((first.path.as_str(), first.offset_sec), ("/c1.mp4", 0.5));
+        // A shown camera after an unshown one keeps its index; nothing shown is an empty list.
+        let sources = [camera("/a.mp4", 0.0), camera("/b.mp4", 0.0), camera("/c.mp4", 0.0)];
+        let keys = extra_camera_keys(&[3], &sources);
+        assert_eq!(keys.len(), 3);
+        assert!(keys[0].is_none() && keys[1].is_none());
+        assert_eq!(keys[2].as_ref().map(|k| k.path.as_str()), Some("/c.mp4"));
+        assert!(extra_camera_keys(&[], &sources).is_empty());
+        assert!(extra_camera_keys(&[2], &[camera("/a.mp4", 0.0)]).is_empty());
+    }
+
+    #[test]
+    fn an_extra_camera_is_decoded_only_near_its_regions() {
+        let regions = scene_for_clip(&layout_scene(), 0).camera_layout_regions;
+        // From PREFETCH_LEAD_SEC before the region to its end.
+        assert!(!extra_camera_active(&regions, 1, 2.0 - PREFETCH_LEAD_SEC - 0.01));
+        assert!(extra_camera_active(&regions, 1, 2.0 - PREFETCH_LEAD_SEC));
+        assert!(extra_camera_active(&regions, 1, 3.0));
+        assert!(extra_camera_active(&regions, 1, 5.0));
+        assert!(!extra_camera_active(&regions, 1, 5.01));
+        // A camera the region does not show, and one only an empty region names.
+        assert!(!extra_camera_active(&regions, 3, 7.0));
+        assert!(!extra_camera_active(&[], 1, 3.0));
+    }
+
+    /// Playing on with the same files and region timing, a scene push does not seek the extra
+    /// cameras again; any change that matters, a jump, or a pause does.
+    #[test]
+    fn extra_cameras_are_sought_again_only_when_it_matters() {
+        assert!(!extras_need_seek(false, false, true));
+        assert!(extras_need_seek(true, false, true), "new files");
+        assert!(extras_need_seek(false, true, true), "regions moved");
+        assert!(extras_need_seek(false, false, false), "paused, or the position jumped");
+
+        let regions = scene_for_clip(&layout_scene(), 0).camera_layout_regions;
+        assert!(same_region_timing(&regions, &regions.clone()));
+        // A moved rect is the same timing; a moved bound or another camera is not.
+        let mut moved_rect = regions.clone();
+        moved_rect[0].layers[0].rect.x += 0.1;
+        assert!(same_region_timing(&regions, &moved_rect));
+        let mut moved_end = regions.clone();
+        moved_end[0].end_sec += 0.5;
+        assert!(!same_region_timing(&regions, &moved_end));
+        let mut other_camera = regions.clone();
+        other_camera[0].layers[0].camera = 3;
+        assert!(!same_region_timing(&regions, &other_camera));
+        assert!(!same_region_timing(&regions, &regions[..1]));
+    }
+
+    #[test]
+    fn a_missing_extra_camera_skips_its_layer() {
+        let failed: Result<u8> = Err(anyhow::anyhow!("0-byte file"));
+        assert_eq!(opened_or_skipped("/c1.mp4", failed), None);
+        assert_eq!(opened_or_skipped("/c1.mp4", Ok(7u8)), Some(7));
+
+        // Slot 0 failed to open, slot 1 is open with a frame, slot 2 is open with nothing to
+        // show (idle or past its end): only slot 1 hands a frame to the compositor.
+        let frame = 0x10usize as *const AVFrame;
+        let slots = [None, Some(frame), Some(std::ptr::null())];
+        let list = extra_frame_list(&slots, |f| *f);
+        assert_eq!(list, vec![std::ptr::null(), frame, std::ptr::null()]);
+        assert!(extra_frame_list::<*const AVFrame>(&[], |f| *f).is_empty());
+    }
+
+    #[test]
+    fn the_pool_key_includes_the_extra_cameras() {
+        let key = |extras: ExtraCameraKeys| ClipKey {
+            screen_path: "/s0.mp4".into(),
+            webcam_path: "/w0.mp4".into(),
+            webcam_offset_sec: 0.0,
+            extras,
+        };
+        let with_camera_1 = key(vec![Some(camera("/c1.mp4", 0.5))]);
+        assert!(with_camera_1.matches(&key(vec![Some(camera("/c1.mp4", 0.5))])));
+        // Same screen and camera 0, but camera 1 missing, another file or another offset.
+        assert!(!with_camera_1.matches(&key(Vec::new())));
+        assert!(!with_camera_1.matches(&key(vec![Some(camera("/other.mp4", 0.5))])));
+        assert!(!with_camera_1.matches(&key(vec![Some(camera("/c1.mp4", 0.75))])));
+        assert!(!with_camera_1.matches(&key(vec![None, Some(camera("/c1.mp4", 0.5))])));
+        assert!(key(Vec::new()).matches(&key(Vec::new())));
     }
 
     #[test]
diff --git a/crates/compositor/src/pipeline_linux.rs b/crates/compositor/src/pipeline_linux.rs
index 1c47e0b0f..c31eb494f 100644
--- a/crates/compositor/src/pipeline_linux.rs
+++ b/crates/compositor/src/pipeline_linux.rs
@@ -54,8 +54,13 @@ pub struct ClipSource {
     pub source_end_sec: f64,
     pub webcam_offset_sec: f64,
     pub has_audio: bool,
+    /// Cameras 2-4 of the clip (index k-1 = camera k, an empty `path` = none). Only those a
+    /// layout region of the clip shows are decoded.
+    pub additional_cameras: Vec<ClipCamera>,
 }
 
+pub use crate::extra_cameras::ClipCamera;
+
 /// Codec cible. Memes variantes que `pipeline_macos::ExportCodec`.
 #[derive(Clone, Copy, Debug)]
 pub enum ExportCodec {
@@ -945,6 +950,7 @@ pub fn run_composited_multi(
 
     let mut screen_decs: HashMap<String, Decoder> = HashMap::new();
     let mut webcam_decs: HashMap<String, Decoder> = HashMap::new();
+    let mut extra_decs: HashMap<String, Decoder> = HashMap::new();
 
     // ---- muxer MP4 (flux video + flux AAC) ----
     let outc = CString::new(out)?;
@@ -1038,6 +1044,7 @@ pub fn run_composited_multi(
             &scene,
             &mut screen_decs,
             &mut webcam_decs,
+            &mut extra_decs,
             &mut |n| {
                 // Soumet la copie de la frame n SANS l'attendre et recolte la
                 // precedente : c'est tout le pipelining GPU. L'encodage, lui,
diff --git a/crates/compositor/src/pipeline_macos.rs b/crates/compositor/src/pipeline_macos.rs
index ad43084a0..6fc75f01a 100644
--- a/crates/compositor/src/pipeline_macos.rs
+++ b/crates/compositor/src/pipeline_macos.rs
@@ -663,8 +663,13 @@ pub struct ClipSource {
     pub source_end_sec: f64,
     pub webcam_offset_sec: f64,
     pub has_audio: bool,
+    /// Cameras 2-4 of the clip (index k-1 = camera k, an empty `path` = none). Only those a
+    /// layout region of the clip shows are decoded.
+    pub additional_cameras: Vec<ClipCamera>,
 }
 
+pub use crate::extra_cameras::ClipCamera;
+
 /// Codec cible pour l'export. Identique à `pipeline_windows::ExportCodec`.
 pub enum ExportCodec {
     H264,
@@ -1160,6 +1165,8 @@ pub fn run_composited_multi(
         std::collections::HashMap::new();
     let mut webcam_decs: std::collections::HashMap<String, Decoder> =
         std::collections::HashMap::new();
+    let mut extra_decs: std::collections::HashMap<String, Decoder> =
+        std::collections::HashMap::new();
 
     // ---- encodeur (candidat VT ou software) ----
     let mut enc =
@@ -1241,6 +1248,7 @@ pub fn run_composited_multi(
             &scene,
             &mut screen_decs,
             &mut webcam_decs,
+            &mut extra_decs,
             &mut |n| {
                 enc.send_composited(comp, out_w, out_h, n as i64)?;
                 {
diff --git a/crates/compositor/src/pipeline_windows.rs b/crates/compositor/src/pipeline_windows.rs
index a232f06b7..8094fd44b 100644
--- a/crates/compositor/src/pipeline_windows.rs
+++ b/crates/compositor/src/pipeline_windows.rs
@@ -1284,8 +1284,13 @@ pub struct ClipSource {
     pub source_end_sec: f64,
     pub webcam_offset_sec: f64,
     pub has_audio: bool,
+    /// Cameras 2-4 of the clip (index k-1 = camera k, an empty `path` = none). Only those a
+    /// layout region of the clip shows are decoded.
+    pub additional_cameras: Vec<ClipCamera>,
 }
 
+pub use crate::extra_cameras::ClipCamera;
+
 /// Export **multiclip** : rend la timeline (clips ordonnés, avec trims) en un seul MP4.
 /// Perf (contrainte §multiclip) : décodeurs ouverts une fois par source (cache) et réutilisés
 /// entre clips du même asset ; **un seul seek keyframe par frontière de clip** ; décodage
@@ -1650,6 +1655,7 @@ unsafe fn run_multi_inner(
     // pour deux &mut indépendants).
     let mut screen_decs: HashMap<String, Decoder> = HashMap::new();
     let mut webcam_decs: HashMap<String, Decoder> = HashMap::new();
+    let mut extra_decs: HashMap<String, Decoder> = HashMap::new();
 
     // fps de sortie : choix explicite de l'app si fourni, sinon dérivé du 1er clip (recordings
     // uniformes) — comportement historique.
@@ -1730,6 +1736,7 @@ unsafe fn run_multi_inner(
         &scene,
         &mut screen_decs,
         &mut webcam_decs,
+        &mut extra_decs,
         &mut |frame_index| {
             // Backend CPU (WARP) : la frame composée descend en mémoire système via
             // `send_composited` (le compositeur relit son NV12 interne vers un AVFrame
diff --git a/crates/compositor/src/regions.rs b/crates/compositor/src/regions.rs
index c00cc4d83..971525b53 100644
--- a/crates/compositor/src/regions.rs
+++ b/crates/compositor/src/regions.rs
@@ -8,7 +8,9 @@
 
 use crate::camera::Follow;
 use crate::cursor::CursorTrack;
-use crate::scene::{SceneCameraFullscreenRegion, SceneSpeedRegion, SceneZoomRegion};
+use crate::scene::{
+    SceneCameraFullscreenRegion, SceneCameraLayoutRegion, SceneSpeedRegion, SceneZoomRegion,
+};
 
 /// Quantification commune vidéo/audio : le web retranche exactement 1 ms avant `ceil`.
 pub const SPEED_FRAME_EPSILON_SEC: f64 = 0.001;
@@ -271,8 +273,11 @@ fn push_speed_segment(
 }
 
 // mêmes fenêtres de transition que le web (TRANSITION_WINDOW_MS etc., converties en secondes).
-const TRANSITION_WINDOW_S: f32 = 1.01505;
-const FULLSCREEN_LEAD_OUT_WINDOW_S: f32 = TRANSITION_WINDOW_S * 1.5;
+pub(crate) const TRANSITION_WINDOW_S: f32 = 1.01505;
+pub(crate) const FULLSCREEN_LEAD_OUT_WINDOW_S: f32 = TRANSITION_WINDOW_S * 1.5;
+/// Two camera regions (layout or Full Camera) closer than this (source seconds) meet at a
+/// seam: they hand over directly, without the default PiP in between.
+pub(crate) const REGION_SEAM_S: f64 = 0.001;
 // Durée d'un zoom à l'écran selon l'échelle visée, cf. `zoom_transition_s` ; miroir de
 // `ZOOM_TRANSITION_BASE_MS` / `ZOOM_TRANSITION_PER_LN_MS` (TS).
 const ZOOM_TRANSITION_BASE_S: f32 = 0.6;
@@ -328,7 +333,7 @@ fn cubic_bezier(x1: f32, y1: f32, x2: f32, y2: f32, t: f32) -> f32 {
 }
 
 /// Port de `easeOutScreenStudio` (TS) : cubic-bezier(0.16, 1, 0.3, 1).
-fn ease_out_screen_studio(t: f32) -> f32 {
+pub(crate) fn ease_out_screen_studio(t: f32) -> f32 {
     cubic_bezier(0.16, 1.0, 0.3, 1.0, t)
 }
 
@@ -973,16 +978,20 @@ fn camera_fullscreen_region_phase(
     region: &SceneCameraFullscreenRegion,
     t: f32,
     clock: &ScreenClock,
+    layouts: &[SceneCameraLayoutRegion],
 ) -> f32 {
     let start = region.start_sec as f32;
     let end = region.end_sec as f32;
     if t <= start || t >= end {
         return 0.0;
     }
+    // At a seam with a layout region the camera is already frame-filling on that side: the
+    // layout region's own glide (`camera_layers_at`) moves it, so the phase holds 1 there.
+    let seams = full_camera_seams(region, layouts);
     let (start, end, t) = (clock.at(start), clock.at(end), clock.at(t));
     let half = (end - start) * 0.5;
-    let lead_in = TRANSITION_WINDOW_S.min(half);
-    let lead_out = FULLSCREEN_LEAD_OUT_WINDOW_S.min(half);
+    let lead_in = if seams.start { 0.0 } else { TRANSITION_WINDOW_S.min(half) };
+    let lead_out = if seams.end { 0.0 } else { FULLSCREEN_LEAD_OUT_WINDOW_S.min(half) };
     let lead_in_end = start + lead_in;
     let lead_out_start = end - lead_out;
     if t < lead_in_end {
@@ -1002,16 +1011,38 @@ fn camera_fullscreen_region_phase(
     }
 }
 
+/// Which ends of a Full Camera region meet a (non-empty) camera layout region at a seam
+/// (`REGION_SEAM_S`): `start` = a layout region ends where it starts, `end` = one starts where
+/// it ends.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub(crate) struct FullCameraSeams {
+    pub start: bool,
+    pub end: bool,
+}
+
+pub(crate) fn full_camera_seams(
+    region: &SceneCameraFullscreenRegion,
+    layouts: &[SceneCameraLayoutRegion],
+) -> FullCameraSeams {
+    let mut seams = FullCameraSeams::default();
+    for l in layouts.iter().filter(|l| l.end_sec > l.start_sec) {
+        seams.start |= (l.end_sec - region.start_sec).abs() <= REGION_SEAM_S;
+        seams.end |= (l.start_sec - region.end_sec).abs() <= REGION_SEAM_S;
+    }
+    seams
+}
+
 /// Phase Full Camera (0..1) au temps `t`. Régions superposées (ne devrait pas arriver, gardé
 /// défensif comme le web) → la plus forte gagne.
 fn camera_fullscreen_phase_at(
     regions: &[SceneCameraFullscreenRegion],
     t: f32,
     clock: &ScreenClock,
+    layouts: &[SceneCameraLayoutRegion],
 ) -> f32 {
     let mut strongest = 0.0f32;
     for r in regions {
-        let s = camera_fullscreen_region_phase(r, t, clock);
+        let s = camera_fullscreen_region_phase(r, t, clock, layouts);
         if s > strongest {
             strongest = s;
         }
@@ -1024,8 +1055,9 @@ pub fn camera_fullscreen_progress_at(
     regions: &[SceneCameraFullscreenRegion],
     t: f32,
     clock: &ScreenClock,
+    layouts: &[SceneCameraLayoutRegion],
 ) -> f32 {
-    ease_out_screen_studio(camera_fullscreen_phase_at(regions, t, clock))
+    ease_out_screen_studio(camera_fullscreen_phase_at(regions, t, clock, layouts))
 }
 
 /// Ce qui reste de la bulle PiP (coins arrondis, ombre) au temps `t` : 1 = bulle entière,
@@ -1038,8 +1070,9 @@ pub fn camera_fullscreen_shape_at(
     regions: &[SceneCameraFullscreenRegion],
     t: f32,
     clock: &ScreenClock,
+    layouts: &[SceneCameraLayoutRegion],
 ) -> f32 {
-    1.0 - smoothstep(0.5, 1.0, camera_fullscreen_phase_at(regions, t, clock))
+    1.0 - smoothstep(0.5, 1.0, camera_fullscreen_phase_at(regions, t, clock, layouts))
 }
 
 /// The Full Camera region in effect at `t`: the one with the strongest phase, so a region's
@@ -1049,10 +1082,11 @@ pub fn camera_fullscreen_region_at<'a>(
     regions: &'a [SceneCameraFullscreenRegion],
     t: f32,
     clock: &ScreenClock,
+    layouts: &[SceneCameraLayoutRegion],
 ) -> Option<&'a SceneCameraFullscreenRegion> {
     let mut best: Option<(&'a SceneCameraFullscreenRegion, f32)> = None;
     for r in regions {
-        let phase = camera_fullscreen_region_phase(r, t, clock);
+        let phase = camera_fullscreen_region_phase(r, t, clock, layouts);
         if phase > 0.0 && best.map_or(true, |(_, b)| phase > b) {
             best = Some((r, phase));
         }
@@ -1068,25 +1102,28 @@ pub const DESK_COVER_FADE_S: f32 = 0.5;
 /// turned section (a camera tilted onto the desk) is covered: the camera is moving at both
 /// ends of such a section, so the picture is hidden for exactly the grow and the shrink, plus a
 /// short fade into and out of the steady part. Measured on screen time like the grow, and 0
-/// on and outside the bounds like the grow.
+/// on and outside the bounds like the grow. At a seam with a layout region (`layouts`) that
+/// side has no grow or shrink to hold over: the cover is only its own fade there.
 pub fn camera_fullscreen_cover_at(
     regions: &[SceneCameraFullscreenRegion],
     t: f32,
     clock: &ScreenClock,
+    layouts: &[SceneCameraLayoutRegion],
 ) -> f32 {
-    let Some(r) = camera_fullscreen_region_at(regions, t, clock) else {
+    let Some(r) = camera_fullscreen_region_at(regions, t, clock, layouts) else {
         return 0.0;
     };
     if r.rotation != 180 {
         return 0.0;
     }
+    let seams = full_camera_seams(r, layouts);
     let (start, end, t) = (clock.at(r.start_sec as f32), clock.at(r.end_sec as f32), clock.at(t));
     // Each hold gets at most half the section; the two fades share what is left, so the start
     // fade ends at or before the point where the end fade begins and the cover never jumps.
     let len = end - start;
     let half = len * 0.5;
-    let hold_in = TRANSITION_WINDOW_S.min(half);
-    let hold_out = FULLSCREEN_LEAD_OUT_WINDOW_S.min(half);
+    let hold_in = if seams.start { 0.0 } else { TRANSITION_WINDOW_S.min(half) };
+    let hold_out = if seams.end { 0.0 } else { FULLSCREEN_LEAD_OUT_WINDOW_S.min(half) };
     let steady = (len - hold_in - hold_out).max(0.0);
     let fade = DESK_COVER_FADE_S.min(steady * 0.5);
     let side = |since: f32, hold: f32, fade: f32| -> f32 {
@@ -2058,9 +2095,9 @@ mod zoom_focus_tests {
                 b.scale
             );
             assert!((a.focus[0] - b.focus[0]).abs() < 1e-4, "t={t}");
-            let a = camera_fullscreen_progress_at(&full_camera(4.0), t, &clock);
+            let a = camera_fullscreen_progress_at(&full_camera(4.0), t, &clock, &[]);
             let b =
-                camera_fullscreen_progress_at(&full_camera(1.0), t / 4.0, &ScreenClock::default());
+                camera_fullscreen_progress_at(&full_camera(1.0), t / 4.0, &ScreenClock::default(), &[]);
             assert!((a - b).abs() < 1e-4, "Full Camera t={t} : {a} vs {b}");
         }
     }
@@ -2082,11 +2119,11 @@ mod zoom_focus_tests {
     fn the_full_camera_region_at_t_is_the_one_the_envelope_uses() {
         let r = [cam(10.0, 20.0, 180), cam(30.0, 40.0, 0)];
         let clock = ScreenClock::default();
-        assert_eq!(camera_fullscreen_region_at(&r, 15.0, &clock).map(|c| c.rotation), Some(180));
-        assert_eq!(camera_fullscreen_region_at(&r, 35.0, &clock).map(|c| c.rotation), Some(0));
+        assert_eq!(camera_fullscreen_region_at(&r, 15.0, &clock, &[]).map(|c| c.rotation), Some(180));
+        assert_eq!(camera_fullscreen_region_at(&r, 35.0, &clock, &[]).map(|c| c.rotation), Some(0));
         for t in [5.0, 10.0, 20.0, 25.0] {
-            assert!(camera_fullscreen_region_at(&r, t, &clock).is_none(), "t={t}");
-            assert_eq!(camera_fullscreen_progress_at(&r, t, &clock), 0.0, "t={t}");
+            assert!(camera_fullscreen_region_at(&r, t, &clock, &[]).is_none(), "t={t}");
+            assert_eq!(camera_fullscreen_progress_at(&r, t, &clock, &[]), 0.0, "t={t}");
         }
     }
 
@@ -2096,7 +2133,7 @@ mod zoom_focus_tests {
     fn a_turned_section_is_covered_while_the_camera_moves() {
         let r = [cam(10.0, 30.0, 180)];
         let clock = ScreenClock::default();
-        let c = |t: f32| camera_fullscreen_cover_at(&r, t, &clock);
+        let c = |t: f32| camera_fullscreen_cover_at(&r, t, &clock, &[]);
         assert_eq!(c(10.0 + 0.01), 1.0, "start of the hold");
         assert_eq!(c(10.0 + TRANSITION_WINDOW_S - 0.01), 1.0, "end of the hold");
         let mid_fade = c(10.0 + TRANSITION_WINDOW_S + DESK_COVER_FADE_S / 2.0);
@@ -2109,12 +2146,65 @@ mod zoom_focus_tests {
         assert_eq!(c(30.0 - 0.01), 1.0);
     }
 
+    fn layout_region(start: f64, end: f64) -> SceneCameraLayoutRegion {
+        SceneCameraLayoutRegion { clip_index: None, start_sec: start, end_sec: end, layers: Vec::new() }
+    }
+
+    /// A layout region meeting a Full Camera region at a seam: the phase holds 1 on that side
+    /// (no lead-out before it, no lead-in after it); the other side is unchanged.
+    #[test]
+    fn the_full_camera_phase_holds_at_a_seam_with_a_layout_region() {
+        let clock = ScreenClock::default();
+        let r = [cam(10.0, 20.0, 0)];
+        let p = |t: f32, layouts: &[SceneCameraLayoutRegion]| {
+            camera_fullscreen_progress_at(&r, t, &clock, layouts)
+        };
+        let after = [layout_region(20.0, 25.0)];
+        let before = [layout_region(5.0, 10.0)];
+        for t in [19.0, 19.5, 19.99] {
+            assert_eq!(p(t, &after), 1.0, "t={t}");
+            assert!(p(t, &[]) < 1.0, "a lone region leads out (t={t})");
+        }
+        assert!(p(10.3, &after) < 1.0, "the far side keeps its lead-in");
+        for t in [10.01, 10.3, 10.9] {
+            assert_eq!(p(t, &before), 1.0, "t={t}");
+        }
+        assert!(p(19.5, &before) < 1.0, "the far side keeps its lead-out");
+        // On the bounds the phase is 0 as always: the layout region draws the seam.
+        assert_eq!(p(20.0, &after), 0.0);
+        assert_eq!(p(10.0, &before), 0.0);
+        // Off the seam (10 ms), or an empty layout region, changes nothing.
+        for layouts in [[layout_region(20.01, 25.0)], [layout_region(20.0, 20.0)]] {
+            assert_eq!(p(19.5, &layouts), p(19.5, &[]));
+        }
+    }
+
+    /// A turned section at a seam: no hold on that side, the cover is its own fade there.
+    #[test]
+    fn at_a_seam_the_cover_is_only_its_fade() {
+        let clock = ScreenClock::default();
+        let r = [cam(10.0, 30.0, 180)];
+        let layouts = [layout_region(5.0, 10.0), layout_region(30.0, 35.0)];
+        let c = |t: f32| camera_fullscreen_cover_at(&r, t, &clock, &layouts);
+        assert!(c(10.001) > 0.99, "covered at the seam: {}", c(10.001));
+        let mid_fade = c(10.0 + DESK_COVER_FADE_S / 2.0);
+        assert!((mid_fade - 0.5).abs() < 1e-3, "half way through the fade: {mid_fade}");
+        assert_eq!(c(10.0 + DESK_COVER_FADE_S + 0.01), 0.0, "sharp after the fade");
+        let mid_rise = c(30.0 - DESK_COVER_FADE_S / 2.0);
+        assert!((mid_rise - 0.5).abs() < 1e-3, "half way up: {mid_rise}");
+        assert_eq!(c(30.0 - DESK_COVER_FADE_S - 0.01), 0.0);
+        assert!(c(29.999) > 0.99);
+        // Without the seams the holds are back.
+        let lone = |t: f32| camera_fullscreen_cover_at(&r, t, &clock, &[]);
+        assert_eq!(lone(10.0 + DESK_COVER_FADE_S + 0.01), 1.0);
+    }
+
     #[test]
     fn the_cover_is_zero_on_and_outside_the_bounds() {
         let r = [cam(10.0, 30.0, 180)];
         let clock = ScreenClock::default();
         for t in [0.0, 9.99, 10.0, 30.0, 30.01, 40.0] {
-            assert_eq!(camera_fullscreen_cover_at(&r, t, &clock), 0.0, "t={t}");
+            assert_eq!(camera_fullscreen_cover_at(&r, t, &clock, &[]), 0.0, "t={t}");
         }
     }
 
@@ -2124,7 +2214,7 @@ mod zoom_focus_tests {
         let clock = ScreenClock::default();
         for step in 0..=400 {
             let t = step as f32 * 0.1;
-            assert_eq!(camera_fullscreen_cover_at(&r, t, &clock), 0.0, "t={t}");
+            assert_eq!(camera_fullscreen_cover_at(&r, t, &clock, &[]), 0.0, "t={t}");
         }
     }
 
@@ -2136,13 +2226,13 @@ mod zoom_focus_tests {
         let short = [cam(10.0, 11.5, 180)]; // half = 0.75 < hold-in: no fade at all
         for step in 1..150 {
             let t = 10.0 + step as f32 * 0.01;
-            let c = camera_fullscreen_cover_at(&short, t, &clock);
+            let c = camera_fullscreen_cover_at(&short, t, &clock, &[]);
             assert!((0.0..=1.0).contains(&c), "t={t}: {c}");
             assert_eq!(c, 1.0, "a section shorter than both holds is covered throughout (t={t})");
         }
         // 3.6 s: steady = 3.6 - 1.015 - 1.523 = 1.06, so both ends keep their full 0.5 s fade.
         let medium = [cam(10.0, 13.6, 180)];
-        let c = |t: f32| camera_fullscreen_cover_at(&medium, t, &clock);
+        let c = |t: f32| camera_fullscreen_cover_at(&medium, t, &clock, &[]);
         let mid_fade = c(10.0 + TRANSITION_WINDOW_S + DESK_COVER_FADE_S / 2.0);
         assert!((mid_fade - 0.5).abs() < 1e-3, "start fade half way: {mid_fade}");
         let mid_rise = c(13.6 - FULLSCREEN_LEAD_OUT_WINDOW_S - DESK_COVER_FADE_S / 2.0);
@@ -2155,7 +2245,7 @@ mod zoom_focus_tests {
     fn medium_sections_share_the_steady_part_between_the_fades() {
         let clock = ScreenClock::default();
         let r = [cam(10.0, 12.6, 180)];
-        let c = |t: f32| camera_fullscreen_cover_at(&r, t, &clock);
+        let c = |t: f32| camera_fullscreen_cover_at(&r, t, &clock, &[]);
         let fade = (2.6 - TRANSITION_WINDOW_S - 1.3) / 2.0;
         let meet = 10.0 + TRANSITION_WINDOW_S + fade;
         let mid_fade = c(10.0 + TRANSITION_WINDOW_S + fade / 2.0);
@@ -2175,10 +2265,10 @@ mod zoom_focus_tests {
         for len in [2.0_f32, 2.2, 2.6, 3.0, 3.5, 4.0, 4.5] {
             let r = [cam(10.0, 10.0 + len as f64, 180)];
             let steps = (len * 1000.0).round() as i32;
-            let mut prev = camera_fullscreen_cover_at(&r, 10.0 + 0.0005, &clock);
+            let mut prev = camera_fullscreen_cover_at(&r, 10.0 + 0.0005, &clock, &[]);
             for step in 1..steps {
                 let t = 10.0 + step as f32 * 0.001;
-                let c = camera_fullscreen_cover_at(&r, t, &clock);
+                let c = camera_fullscreen_cover_at(&r, t, &clock, &[]);
                 assert!((0.0..=1.0).contains(&c), "len={len} t={t}: {c}");
                 assert!((c - prev).abs() <= 0.1, "len={len} t={t}: {prev} -> {c}");
                 prev = c;
@@ -2192,8 +2282,8 @@ mod zoom_focus_tests {
         let clock = ScreenClock::new(&[speed(None, 0.0, 1000.0, 2.0)], 0);
         let r = [cam(10.0, 40.0, 180)];
         // At 2x, the 1.015 s hold spans 2.03 s of source time.
-        assert_eq!(camera_fullscreen_cover_at(&r, 10.0 + 1.9, &clock), 1.0);
-        assert!(camera_fullscreen_cover_at(&r, 10.0 + 3.6, &clock) < 1.0);
+        assert_eq!(camera_fullscreen_cover_at(&r, 10.0 + 1.9, &clock, &[]), 1.0);
+        assert!(camera_fullscreen_cover_at(&r, 10.0 + 3.6, &clock, &[]) < 1.0);
     }
     #[test]
     fn the_region_fields_parse_and_default() {
@@ -2221,7 +2311,7 @@ mod zoom_focus_tests {
         }];
         let clock = ScreenClock::default();
         let at = |t: f32| {
-            (camera_fullscreen_progress_at(&r, t, &clock), camera_fullscreen_shape_at(&r, t, &clock))
+            (camera_fullscreen_progress_at(&r, t, &clock, &[]), camera_fullscreen_shape_at(&r, t, &clock, &[]))
         };
         // Premier tiers de la montée : la caméra a fait l'essentiel du chemin, coins intacts.
         let (progress, shape) = at(10.0 + TRANSITION_WINDOW_S / 3.0);
diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs
index a7ca6c13a..98a5957c4 100644
--- a/crates/compositor/src/scene.rs
+++ b/crates/compositor/src/scene.rs
@@ -19,6 +19,67 @@ pub struct SceneClip {
     /// Une source sans piste audio décodable garde sa durée via du silence natif.
     #[serde(default)]
     pub has_audio: bool,
+    /// Cameras 2-4: index k-1 = camera k. An empty `path` means "no camera in this slot".
+    #[serde(default)]
+    pub additional_cameras: Vec<SceneClipCamera>,
+}
+
+/// An additional camera (2-4) of a clip. = `CompositorClipCamera` (TS).
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SceneClipCamera {
+    pub path: String,
+    /// Camera source time = screen source time - this.
+    pub offset_sec: f64,
+}
+
+/// Settings of one camera (index 0 = camera 1). With a `homography` the camera's rotation,
+/// mirror and crop are not sent (the corner order already defines the picture).
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SceneCamera {
+    pub index: usize,
+    /// 0 or 180.
+    #[serde(default)]
+    pub rotation: u16,
+    #[serde(default)]
+    pub mirror: Option<bool>,
+    #[serde(default)]
+    pub crop: Option<SceneCrop>,
+    /// Row-major 3x3, target uv -> camera uv.
+    #[serde(default)]
+    pub homography: Option<[f32; 9]>,
+    /// Width/height of the corrected picture.
+    #[serde(default)]
+    pub aspect: Option<f32>,
+}
+
+/// One camera placed by a layout region, in draw order.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SceneCameraLayer {
+    pub camera: usize,
+    pub rect: SceneRect,
+    #[serde(default)]
+    pub radius_frac: f32,
+    /// Same vocabulary as `SceneLayout::webcam_shape` (`webcam_shape_code`).
+    #[serde(default)]
+    pub shape: String,
+    /// Covers the screen: drawn without a shadow.
+    #[serde(default)]
+    pub fills_frame: bool,
+}
+
+/// A camera layout (anything but a plain Full Camera) on a span of a clip's source time.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SceneCameraLayoutRegion {
+    #[serde(default)]
+    pub clip_index: Option<usize>,
+    pub start_sec: f64,
+    pub end_sec: f64,
+    #[serde(default)]
+    pub layers: Vec<SceneCameraLayer>,
 }
 
 #[derive(Debug, Clone, Copy, Deserialize)]
@@ -740,6 +801,12 @@ pub struct Scene {
     /// `#[serde(default)]` : champ ajouté après coup, absent des JSON de test existants.
     #[serde(default)]
     pub camera_fullscreen_regions: Vec<SceneCameraFullscreenRegion>,
+    /// Settings of the cameras that have any (see `Scene::camera`).
+    #[serde(default)]
+    pub cameras: Vec<SceneCamera>,
+    /// Layouts that put several cameras on screen. Absent = none.
+    #[serde(default)]
+    pub camera_layout_regions: Vec<SceneCameraLayoutRegion>,
     pub cursor: SceneCursor,
     /// Global audio finishing. Default keeps old scene payloads bit-for-bit compatible.
     #[serde(default)]
@@ -761,6 +828,11 @@ pub struct Scene {
 }
 
 impl Scene {
+    /// The settings of camera `index` (0 = camera 1), if the scene carries any.
+    pub fn camera(&self, index: usize) -> Option<&SceneCamera> {
+        self.cameras.iter().find(|c| c.index == index)
+    }
+
     /// Parse le JSON produit par `buildSceneDescription` (TS).
     pub fn from_json(json: &str) -> anyhow::Result<Scene> {
         Ok(serde_json::from_str(json)?)
@@ -798,6 +870,9 @@ impl Scene {
         scene.camera_fullscreen_regions.retain(|region| {
             belongs(region.clip_index, region.start_sec, region.end_sec)
         });
+        scene.camera_layout_regions.retain(|region| {
+            belongs(region.clip_index, region.start_sec, region.end_sec)
+        });
         scene.annotations.retain(|annotation| {
             belongs(annotation.clip_index, annotation.start_sec, annotation.end_sec)
         });
@@ -953,6 +1028,83 @@ mod tests {
         }
     }
 
+    /// A scene JSON with one clip; the arguments are spliced in as extra clip / top-level fields.
+    fn scene_json_with(clip_extra: &str, top_extra: &str) -> String {
+        format!(
+            r##"{{"clips":[{{"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0{clip_extra}}}],"layout":{{"preset":"picture-in-picture","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0}},"background":{{"kind":"color","color":"#000000"}},"zoomRegions":[],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":null}}{top_extra}}}"##
+        )
+    }
+
+    #[test]
+    fn parses_extra_cameras_settings_and_layout_regions() {
+        let json = scene_json_with(
+            r#","additionalCameras":[{"path":"/w-2.mp4","offsetSec":0.12},{"path":"","offsetSec":0}]"#,
+            r#","cameras":[{"index":1,"rotation":180,"mirror":true,"crop":{"x":0,"y":0.1,"width":0.5,"height":0.8}},{"index":2,"homography":[1,0,0,0,1,0,0,0,1],"aspect":1.5}],
+            "cameraLayoutRegions":[{"clipIndex":0,"startSec":1,"endSec":4,"underTrim":true,"layers":[
+                {"camera":1,"rect":{"x":0,"y":0,"width":1,"height":1},"radiusFrac":0,"shape":"rectangle","fillsFrame":true},
+                {"camera":0,"rect":{"x":0.7,"y":0.7,"width":0.22,"height":0.2},"radiusFrac":0.12,"shape":"rounded","fillsFrame":false}]}]"#,
+        );
+        let s = Scene::from_json(&json).expect("parse");
+        assert_eq!(s.clips[0].additional_cameras.len(), 2);
+        assert_eq!(s.clips[0].additional_cameras[0].path, "/w-2.mp4");
+        assert!((s.clips[0].additional_cameras[0].offset_sec - 0.12).abs() < 1e-9);
+        assert_eq!(s.clips[0].additional_cameras[1].path, "");
+        assert!(s.camera(0).is_none());
+        let c1 = s.camera(1).expect("camera 1");
+        assert_eq!(c1.rotation, 180);
+        assert_eq!(c1.mirror, Some(true));
+        assert_eq!(c1.crop.expect("crop").height, 0.8);
+        assert!(c1.homography.is_none() && c1.aspect.is_none());
+        let c2 = s.camera(2).expect("camera 2");
+        assert_eq!(c2.rotation, 0);
+        assert_eq!(c2.homography, Some([1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0]));
+        assert_eq!(c2.aspect, Some(1.5));
+        assert_eq!(s.camera_layout_regions.len(), 1);
+        let r = &s.camera_layout_regions[0];
+        assert_eq!((r.clip_index, r.start_sec, r.end_sec), (Some(0), 1.0, 4.0));
+        assert_eq!(r.layers.len(), 2);
+        assert_eq!(r.layers[0].camera, 1);
+        assert!(r.layers[0].fills_frame);
+        assert_eq!(r.layers[1].shape, "rounded");
+        assert!((r.layers[1].radius_frac - 0.12).abs() < 1e-6);
+        assert!((r.layers[1].rect.width - 0.22).abs() < 1e-6);
+    }
+
+    #[test]
+    fn old_scene_json_parses_without_the_new_fields() {
+        let s = Scene::from_json(&scene_json_with("", "")).expect("parse");
+        assert!(s.clips[0].additional_cameras.is_empty());
+        assert!(s.cameras.is_empty());
+        assert!(s.camera_layout_regions.is_empty());
+        assert!(s.camera(0).is_none());
+    }
+
+    #[test]
+    fn for_clip_window_keeps_only_this_clips_layout_regions() {
+        let layers = r#""layers":[{"camera":0,"rect":{"x":0,"y":0,"width":1,"height":1},"radiusFrac":0,"shape":"rectangle","fillsFrame":true}]"#;
+        let json = scene_json_with(
+            "",
+            &format!(
+                r#","cameraLayoutRegions":[
+                {{"clipIndex":0,"startSec":1,"endSec":2,{layers}}},
+                {{"clipIndex":1,"startSec":1,"endSec":2,{layers}}},
+                {{"startSec":8,"endSec":9,{layers}}},
+                {{"startSec":20,"endSec":30,{layers}}}]"#
+            ),
+        );
+        let s = Scene::from_json(&json).expect("parse");
+        let w = s.for_clip_window(0, 0.0, 10.0);
+        // Clip 0's own region and the unaddressed one that overlaps the window; not clip 1's,
+        // not the unaddressed one outside the window.
+        let kept: Vec<(Option<usize>, f64)> = w
+            .camera_layout_regions
+            .iter()
+            .map(|r| (r.clip_index, r.start_sec))
+            .collect();
+        assert_eq!(kept, vec![(Some(0), 1.0), (None, 8.0)]);
+        assert_eq!(s.for_clip_window(1, 0.0, 10.0).camera_layout_regions.len(), 2);
+    }
+
     #[test]
     fn parses_webcam_rect_payload() {
         // webcamRect est une fraction 0..1 du cadre de sortie ; sa présence doit désactiver
diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlsl
index 8e1b1bc2a..e5777929e 100644
--- a/crates/compositor/src/shaders.hlsl
+++ b/crates/compositor/src/shaders.hlsl
@@ -24,6 +24,8 @@ cbuffer Layer : register(b0)
     float4 trail_b;   // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortie
     float4 trail_mb;  // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; mode 18 incliné : le `mb` du mode 8 (profondeur de champ), et `color.xy` sa lampe ; 0 ailleurs
     float4 cover;     // x = desk-view cover 0..1, y = blur radius (quad px), z = dim, w unused
+    float4 persp[3];  // mode 0: rows of the homography quad point (0..1 in dst) -> camera uv (0..1 of the valid frame), xyz; read when layer_fx.y = 1
+    float4 layer_fx;  // x = transparency 0..1 (0 = opaque), every mode; y = 1 when persp applies; z, w unused
 };
 // Mode 15 (curseur modélisé) : le détail des emplacements est dans `frame_geometry.rs`, en tête
 // de la section « Curseur modélisé » (`cursor_model_cb`). Mode 17 (appareil modelé) : en tête de
@@ -476,6 +478,19 @@ float band_cov(float x, float half_w)
     return saturate(half_w + 0.5 - abs(x));
 }
 
+// Camera homography (`persp`, read when `layer_fx.y` = 1): the camera point (0..1 of its valid
+// frame) seen at `local` (0..1 in the layer's dst quad), and in z whether there is one -- 0 when
+// the point is behind the projection (q.z <= 0) or outside the camera frame, where the layer is
+// transparent.
+float3 persp_camera(float2 local)
+{
+    float3 p = float3(local, 1.0);
+    float3 q = float3(dot(persp[0].xyz, p), dot(persp[1].xyz, p), dot(persp[2].xyz, p));
+    float2 cam = q.xy / max(q.z, 1e-6);
+    bool inside = q.z > 0.0 && all(cam >= 0.0) && all(cam <= 1.0);
+    return float3(cam, inside ? 1.0 : 0.0);
+}
+
 // Fond flouté pour le mode "blur" de la webcam.
 // Disque de Vogel (spirale à angle d'or) à 21 échantillons avec pondération gaussienne et
 // rotation par pixel via Interleaved Gradient Noise (IGN) pour un bokeh photographique doux, isotrope et rapide.
@@ -3479,7 +3494,8 @@ float4 device_frame(float2 local)
     return float4(rgb * a, a); // prémultiplié
 }
 
-float4 ps_main(VSOut i) : SV_Target
+// The body of `ps_main`, which only adds the layer's transparency on top of it.
+float4 ps_layer(VSOut i)
 {
     // mode 18 : l'écran CADRÉ (ombre, cadre, métrage, appareil) flouté comme UN objet rigide
     // (`FrameGeometry::screen_trail`). t2 = son rendu isolé, prémultiplié, à la taille de la
@@ -3991,6 +4007,8 @@ float4 ps_main(VSOut i) : SV_Target
     float3 rgb;
     // 1 sauf en mode detourage, ou il porte le masque du sujet (cf. la branche fx.z ci-dessous).
     float alpha_mask = 1.0;
+    // 0 where a camera homography finds no camera point (`persp_camera`), 1 everywhere else.
+    float persp_keep = 1.0;
     if (mode < 0.5)
     {
         // flou de mouvement par vélocité (§8) : pour CE pixel sortie, uv à la frame
@@ -3999,6 +4017,17 @@ float4 ps_main(VSOut i) : SV_Target
         float2 uv_now = i.uv;
         float2 localp = (i.pout - dst_prev.xy) / dst_prev.zw;
         float2 uv_prev = src_prev.xy + localp * (src_prev.zw - src_prev.xy);
+        if (layer_fx.y > 0.5)
+        {
+            // Camera homography: the texture uv comes from the fragment's place in the quad
+            // (`src` is not used), scaled to the valid part of the decoder texture. The previous
+            // frame's uv is the same map at the quad's previous place.
+            float3 cam = persp_camera((i.pout - dst.xy) / dst.zw);
+            persp_keep = cam.z;
+            uv_now = cam.xy * fx.xy;
+            float3 cam_prev = persp_camera(localp);
+            uv_prev = (cam_prev.z > 0.5) ? cam_prev.xy * fx.xy : uv_now;
+        }
         float2 duv = uv_now - uv_prev;
         float mb_scale = saturate(mb.y);
         float2 duv_blur = duv * mb_scale;
@@ -4060,7 +4089,7 @@ float4 ps_main(VSOut i) : SV_Target
         rgb = color.rgb;
     }
 
-    float alpha = color.a * alpha_mask;
+    float alpha = color.a * alpha_mask * persp_keep;
     if (radius_px > 0.0)
     {
         // `quad_px` est en px de SORTIE (le render target porte la géométrie de sortie) et
@@ -4084,6 +4113,12 @@ float4 ps_main(VSOut i) : SV_Target
     return float4(rgb * alpha, alpha); // prémultiplié
 }
 
+float4 ps_main(VSOut i) : SV_Target
+{
+    // Premultiplied, so the transparency scales all four channels; 0 leaves them as they are.
+    return ps_layer(i) * (1.0 - layer_fx.x);
+}
+
 // ============ RGB -> NV12 (§5) : deux passes vers les plans d'une texture NV12 ============
 // VS plein écran (triangle unique) qui expose l'UV.
 struct FSOut { float4 pos : SV_Position; float2 uv : TEXCOORD0; };
diff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metal
index baf787b1c..b0e2cb40e 100644
--- a/crates/compositor/src/shaders.metal
+++ b/crates/compositor/src/shaders.metal
@@ -48,7 +48,7 @@ using namespace metal;
 // =================================================================================
 //
 // Le moteur côté CPU upload ce buffer via `setVertexBytes` (vertex stage) et
-// `setFragmentBytes` (fragment stage) avant chaque draw — la copie est de 192 octets,
+// `setFragmentBytes` (fragment stage) avant chaque draw — la copie est de 256 octets,
 // ce qui est sous le seuil d'alignement 4K de Metal pour le mode « immediate ».
 
 struct Layer
@@ -67,6 +67,8 @@ struct Layer
     float4 trail_b;   // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortie
     float4 trail_mb;  // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; 0 ailleurs
     float4 cover;     // x = desk-view cover 0..1, y = blur radius (quad px), z = dim, w unused
+    float4 persp[3];  // mode 0: rows of the homography quad point (0..1 in dst) -> camera uv (0..1 of the valid frame), xyz; read when layer_fx.y = 1
+    float4 layer_fx;  // x = transparency 0..1 (0 = opaque), every mode; y = 1 when persp applies; z, w unused
 };
 // Mode 15 (curseur modélisé) : le détail des emplacements est dans `frame_geometry.rs`, en tête
 // de la section « Curseur modélisé » (`cursor_model_cb`). Mode 17 (appareil modelé) : en tête de
@@ -453,6 +455,19 @@ inline float3 blur_webcam_radius(float2 uv, float max_r_px, float2 qpx, float2 l
     return sum / max(total, 1e-4);
 }
 
+// Camera homography (`persp`, read when `layer_fx.y` = 1): the camera point (0..1 of its valid
+// frame) seen at `local` (0..1 in the layer's dst quad), and in z whether there is one -- 0 when
+// the point is behind the projection (q.z <= 0) or outside the camera frame, where the layer is
+// transparent. Mirror of the HLSL `persp_camera`.
+inline float3 persp_camera(constant Layer &layer, float2 local)
+{
+    float3 p = float3(local, 1.0);
+    float3 q = float3(dot(layer.persp[0].xyz, p), dot(layer.persp[1].xyz, p), dot(layer.persp[2].xyz, p));
+    float2 cam = q.xy / max(q.z, 1e-6);
+    bool inside = q.z > 0.0 && all(cam >= 0.0) && all(cam <= 1.0);
+    return float3(cam, inside ? 1.0 : 0.0);
+}
+
 inline float3 blur_webcam_bg(float2 uv, float intensity, float2 qpx, float2 local_px,
                              float2 valid,
                              texture2d<float, access::sample> texY,
@@ -3241,22 +3256,16 @@ static float4 device_frame(float2 local, constant Layer &layer)
     return float4(rgb * a, a); // prémultiplié
 }
 
-fragment float4 ps_main(VSOut i [[stage_in]],
-                        constant Layer &layer [[buffer(0)]],
-                        texture2d<float, access::sample> texY [[texture(0)]],
-                        texture2d<float, access::sample> texUV [[texture(1)]],
-                        texture2d<float, access::sample> texImg [[texture(2)]],
-                        // Masque de segmentation du sujet webcam. Non lie tant qu'aucun
-                        // masque n'existe : Metal rend alors 0, ce qui est sans effet
-                        // puisque la branche n'est prise que si layer.fx.z > 0.5.
-                        texture2d<float, access::sample> texMask [[texture(3)]],
-                        // Champ de distance du sprite de curseur (mode 15 seulement), R16F, cf.
-                        // `cursor_sdf.rs`. Le sprite lui-même est en texture(2), comme aux
-                        // modes 7 et 13.
-                        texture2d<float, access::sample> texSdf [[texture(4)]],
-                        // Pyramide de profondeur de champ (`tilted_sample`), lue par le mode 8 et
-                        // par le repli du mode 18, qui garde texture(2) pour son rendu isolé.
-                        texture2d<float, access::sample> texDof [[texture(5)]])
+// The body of `ps_main`, which only adds the layer's transparency on top of it. Same resources
+// as `ps_main`, without their bindings (MSL only allows those on an entry point).
+inline float4 ps_layer(VSOut i,
+                       constant Layer &layer,
+                       texture2d<float, access::sample> texY,
+                       texture2d<float, access::sample> texUV,
+                       texture2d<float, access::sample> texImg,
+                       texture2d<float, access::sample> texMask,
+                       texture2d<float, access::sample> texSdf,
+                       texture2d<float, access::sample> texDof)
 {
     // mode 18 : l'écran CADRÉ (ombre, cadre, métrage, appareil) flouté comme UN objet rigide
     // (`FrameGeometry::screen_trail`), port 1:1 du HLSL. texImg = son rendu isolé, prémultiplié,
@@ -3747,12 +3756,25 @@ fragment float4 ps_main(VSOut i [[stage_in]],
     float3 rgb;
     // 1 sauf en detourage, ou il porte le masque du sujet. Cf. la branche fx.z plus bas.
     float alpha_mask = 1.0;
+    // 0 where a camera homography finds no camera point (`persp_camera`), 1 everywhere else.
+    float persp_keep = 1.0;
     if (layer.mode < 0.5)
     {
         // flou de mouvement par vélocité (§8)
         float2 uv_now = i.uv;
         float2 localp = (i.pout - layer.dst_prev.xy) / layer.dst_prev.zw;
         float2 uv_prev = layer.src_prev.xy + localp * (layer.src_prev.zw - layer.src_prev.xy);
+        if (layer.layer_fx.y > 0.5)
+        {
+            // Camera homography: the texture uv comes from the fragment's place in the quad
+            // (`src` is not used), scaled to the valid part of the decoder texture. The previous
+            // frame's uv is the same map at the quad's previous place.
+            float3 cam = persp_camera(layer, (i.pout - layer.dst.xy) / layer.dst.zw);
+            persp_keep = cam.z;
+            uv_now = cam.xy * layer.fx.xy;
+            float3 cam_prev = persp_camera(layer, localp);
+            uv_prev = (cam_prev.z > 0.5) ? cam_prev.xy * layer.fx.xy : uv_now;
+        }
         float2 duv = uv_now - uv_prev;
         float mb_scale = saturate(layer.mb.y);
         float2 duv_blur = duv * mb_scale;
@@ -3809,7 +3831,7 @@ fragment float4 ps_main(VSOut i [[stage_in]],
         rgb = layer.color.rgb;
     }
 
-    float alpha = layer.color.a * alpha_mask;
+    float alpha = layer.color.a * alpha_mask * persp_keep;
     if (layer.radius_px > 0.0)
     {
         // mb.w = 1 : écran sous le chrome de fenêtre, coins HAUTS carrés et rognés par l'arc du
@@ -3828,6 +3850,27 @@ fragment float4 ps_main(VSOut i [[stage_in]],
     return float4(rgb * alpha, alpha);
 }
 
+fragment float4 ps_main(VSOut i [[stage_in]],
+                        constant Layer &layer [[buffer(0)]],
+                        texture2d<float, access::sample> texY [[texture(0)]],
+                        texture2d<float, access::sample> texUV [[texture(1)]],
+                        texture2d<float, access::sample> texImg [[texture(2)]],
+                        // Masque de segmentation du sujet webcam. Non lie tant qu'aucun
+                        // masque n'existe : Metal rend alors 0, ce qui est sans effet
+                        // puisque la branche n'est prise que si layer.fx.z > 0.5.
+                        texture2d<float, access::sample> texMask [[texture(3)]],
+                        // Champ de distance du sprite de curseur (mode 15 seulement), R16F, cf.
+                        // `cursor_sdf.rs`. Le sprite lui-même est en texture(2), comme aux
+                        // modes 7 et 13.
+                        texture2d<float, access::sample> texSdf [[texture(4)]],
+                        // Pyramide de profondeur de champ (`tilted_sample`), lue par le mode 8 et
+                        // par le repli du mode 18, qui garde texture(2) pour son rendu isolé.
+                        texture2d<float, access::sample> texDof [[texture(5)]])
+{
+    // Premultiplied, so the transparency scales all four channels; 0 leaves them as they are.
+    return ps_layer(i, layer, texY, texUV, texImg, texMask, texSdf, texDof) * (1.0 - layer.layer_fx.x);
+}
+
 // =================================================================================
 // Fullscreen pass : RGB -> NV12. Mêmes shaders que la passe équivalente HLSL.
 // =================================================================================
diff --git a/crates/compositor/src/timeline_walk.rs b/crates/compositor/src/timeline_walk.rs
index a16271c8b..5a1205ae0 100644
--- a/crates/compositor/src/timeline_walk.rs
+++ b/crates/compositor/src/timeline_walk.rs
@@ -17,13 +17,17 @@ use crate::compositor::Compositor;
 use crate::config::Cfg;
 use crate::cursor::CursorTrack;
 use crate::d3d::Gpu;
+use crate::extra_cameras::{
+    camera_source_time, cameras_in_regions, extra_camera_active, extra_camera_keys, open_once,
+    step_extra_camera,
+};
 use crate::ffi::AVFrame;
 use crate::frame_geometry::webcam_is_real;
 use crate::pipeline::{ClipSource, Decoder};
 use crate::regions::{speed_segments_for_window, SpeedSegment};
-use crate::scene::Scene;
+use crate::scene::{Scene, SceneCameraLayoutRegion};
 use anyhow::Result;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 /// Ce que le décodeur sait de la PROCHAINE frame, sans l'adopter.
 ///
@@ -142,9 +146,24 @@ pub(crate) unsafe fn advance_decoder_to(
 /// N" defined exactly once: a GIF driven by its own loop is how the slow-motion
 /// truncation bug happened.
 ///
+/// The extra cameras (k >= 1) a clip's layout regions show are opened once per path into
+/// `extra_decs`, decoded only near those regions, and handed to the compositor with
+/// `set_extra_camera_frames`. Unlike camera 0 they never shorten a clip, and a file that will
+/// not open (or stops decoding) is skipped with a warning for the rest of the export.
+///
 /// `on_frame` runs after `compose_frame` with the running output index;
 /// `on_clip_end` runs once per clip with its clamped source window, the frames
 /// it produced, and the speed segments used (MP4 needs those for audio).
+/// Runs its closure when dropped, so on every exit path of a scope, early `?` returns
+/// included.
+struct OnExit<F: FnMut()>(F);
+
+impl<F: FnMut()> Drop for OnExit<F> {
+    fn drop(&mut self) {
+        (self.0)();
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 pub(crate) unsafe fn walk_composited_timeline(
     clips: &[ClipSource],
@@ -155,6 +174,7 @@ pub(crate) unsafe fn walk_composited_timeline(
     scene: &Option<Scene>,
     screen_decs: &mut HashMap<String, Decoder>,
     webcam_decs: &mut HashMap<String, Decoder>,
+    extra_decs: &mut HashMap<String, Decoder>,
     on_frame: &mut dyn FnMut(u64) -> Result<()>,
     on_clip_end: &mut dyn FnMut(usize, f64, u64, &[SpeedSegment]) -> Result<()>,
 ) -> Result<u64> {
@@ -168,6 +188,14 @@ pub(crate) unsafe fn walk_composited_timeline(
     let mut cursor_active_path: Option<String> = None;
 
     let mut frames: u64 = 0;
+    let mut unreadable_extras: HashSet<String> = HashSet::new();
+    // The extra decoders outlive this call in the caller's map, but the compositor must not
+    // keep pointers into their frames once the walk is over — also when it fails half-way
+    // (a decode or encode error returns early through `?`).
+    let _forget_extra_frames = OnExit(|| {
+        // SAFETY: an empty list only resets the compositor's slots; no frame is read.
+        unsafe { comp.set_extra_camera_frames(&[]) }
+    });
 
     // L'export doit être reproductible : deux rendus du même projet, les mêmes pixels. Cette
     // boucle avance aussi vite que la machine décode, sans rapport avec le temps réel, alors que
@@ -230,17 +258,12 @@ pub(crate) unsafe fn walk_composited_timeline(
                 clip.source_end_sec,
             );
         }
-        // Les bornes de clip sont en temps écran. La disponibilité webcam est donc translatée
-        // par le même offset que le seek (`webcam_time = screen_time - offset`).
-        let webcam_available_screen_end =
-            webcam_available_duration.map(|duration| duration + clip.webcam_offset_sec);
-        let mut source_end_sec = clip.source_end_sec;
-        if let Some(duration) = screen_available_duration {
-            source_end_sec = source_end_sec.min(duration);
-        }
-        if let Some(duration) = webcam_available_screen_end {
-            source_end_sec = source_end_sec.min(duration);
-        }
+        let source_end_sec = available_clip_end(
+            clip.source_end_sec,
+            screen_available_duration,
+            webcam_available_duration,
+            clip.webcam_offset_sec,
+        );
         if source_end_sec + 1e-6 < clip.source_end_sec {
             eprintln!(
                 "[pipeline] warning: clip #{} raccourci de {:.3}s (fin demandée {:.3}s, fin disponible {:.3}s; screen=\"{}\", webcam=\"{}\")",
@@ -268,6 +291,27 @@ pub(crate) unsafe fn walk_composited_timeline(
             source_end_sec,
             out_fps as f64,
         );
+        // Only the extra cameras this clip's own regions show, and only those it has a file
+        // for. `None` slots stay null in `set_extra_camera_frames`.
+        let camera_regions = clip_scene
+            .as_ref()
+            .map(|s| s.camera_layout_regions.clone())
+            .unwrap_or_default();
+        let mut extras: Vec<Option<ExportExtraCamera>> =
+            extra_camera_keys(&cameras_in_regions(&camera_regions), &clip.additional_cameras)
+                .into_iter()
+                .map(|key| {
+                    let key = key?;
+                    open_once(extra_decs, &mut unreadable_extras, &key.path, |path| {
+                        Decoder::open_for_export(path, gpu)
+                    })
+                    .then_some(ExportExtraCamera {
+                        path: key.path,
+                        offset_sec: key.offset_sec,
+                        ended_at: None,
+                    })
+                })
+                .collect();
         if clip_scene.is_some() {
             comp.set_scene(clip_scene);
         }
@@ -328,6 +372,24 @@ pub(crate) unsafe fn walk_composited_timeline(
                     break 'clip_frames;
                 }
 
+                let (extra_frames, closed) = {
+                    let _p = crate::export_probe::scope(crate::export_probe::Stage::DecodeWebcam);
+                    step_extra_cameras(
+                        &mut extras,
+                        extra_decs,
+                        &mut unreadable_extras,
+                        &camera_regions,
+                        target_source_time,
+                    )
+                };
+                if closed {
+                    // A dropped decoder's textures may still sit in the SRV cache; a later
+                    // decoder could reuse their addresses (same contract as the preview's
+                    // `hand_extra_frames`).
+                    comp.clear_srv_cache();
+                }
+                comp.set_extra_camera_frames(&extra_frames);
+
                 comp.set_timeline_time(Some(target_source_time as f32));
                 // Le temps de SORTIE, lui, ne saute ni aux coupes ni aux clips. Même
                 // arithmétique (f64 puis f32) que `ProgrammeClock::at` côté preview.
@@ -361,9 +423,104 @@ pub(crate) unsafe fn walk_composited_timeline(
     Ok(frames)
 }
 
+/// The screen-time end of a clip: the requested end, clamped to what the screen and camera 0
+/// can deliver. Clip bounds are in screen time, so camera 0's duration is moved by the same
+/// offset as its seek (`webcam_time = screen_time - offset`). The extra cameras do not enter
+/// here: one that ends early only loses its layer, it never shortens the clip.
+fn available_clip_end(
+    requested_end_sec: f64,
+    screen_duration: Option<f64>,
+    webcam_duration: Option<f64>,
+    webcam_offset_sec: f64,
+) -> f64 {
+    let mut end = requested_end_sec;
+    if let Some(duration) = screen_duration {
+        end = end.min(duration);
+    }
+    if let Some(duration) = webcam_duration {
+        end = end.min(duration + webcam_offset_sec);
+    }
+    end
+}
+
+/// An extra camera of the clip being exported; its decoder lives in `extra_decs` under `path`.
+struct ExportExtraCamera {
+    path: String,
+    offset_sec: f64,
+    /// See `step_extra_camera`.
+    ended_at: Option<f64>,
+}
+
+/// The frames for `set_extra_camera_frames` at screen source time `t`: each camera that is
+/// near one of its regions steps toward its own source time, the others give null. A camera
+/// that stops decoding is dropped with a warning and not reopened for the rest of the export;
+/// the `bool` says one was dropped, so the caller clears the compositor's texture cache.
+unsafe fn step_extra_cameras(
+    extras: &mut [Option<ExportExtraCamera>],
+    extra_decs: &mut HashMap<String, Decoder>,
+    unreadable: &mut HashSet<String>,
+    regions: &[SceneCameraLayoutRegion],
+    t: f64,
+) -> (Vec<*const AVFrame>, bool) {
+    let mut closed = false;
+    let mut frames = Vec::with_capacity(extras.len());
+    for (k, slot) in extras.iter_mut().enumerate() {
+        let camera = k + 1;
+        let mut frame: *const AVFrame = std::ptr::null();
+        if let Some(cam) = slot.as_mut().filter(|_| extra_camera_active(regions, camera, t)) {
+            if let Some(dec) = extra_decs.get_mut(&cam.path) {
+                let target = camera_source_time(t, cam.offset_sec);
+                match step_extra_camera(dec, &mut cam.ended_at, target) {
+                    Ok(f) => frame = f,
+                    Err(e) => {
+                        eprintln!(
+                            "WARNING: extra camera {camera} stopped decoding ({}): {e:#}. Its layer will not be drawn.",
+                            cam.path
+                        );
+                        extra_decs.remove(&cam.path);
+                        unreadable.insert(cam.path.clone());
+                        *slot = None;
+                        closed = true;
+                    }
+                }
+            }
+        }
+        frames.push(frame);
+    }
+    (frames, closed)
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{frame_step, FrameStep, NextFrameTime};
+    use super::{available_clip_end, frame_step, FrameStep, NextFrameTime, OnExit};
+
+    /// The guard that forgets the extra camera frames runs on an early `?` return as well as
+    /// at the end of the walk.
+    #[test]
+    fn the_exit_guard_runs_on_every_exit_path() {
+        fn walk(fail: bool, ran: &std::cell::Cell<u32>) -> anyhow::Result<()> {
+            let _guard = OnExit(|| ran.set(ran.get() + 1));
+            if fail {
+                Err(anyhow::anyhow!("decode error"))?;
+            }
+            Ok(())
+        }
+        let ran = std::cell::Cell::new(0);
+        assert!(walk(true, &ran).is_err());
+        assert_eq!(ran.get(), 1, "early return");
+        assert!(walk(false, &ran).is_ok());
+        assert_eq!(ran.get(), 2, "normal end");
+    }
+
+    #[test]
+    fn a_short_extra_camera_does_not_shorten_the_clip() {
+        // Screen 60 s, camera 0 50 s at offset 2 s: the clip ends where camera 0 does.
+        assert_eq!(available_clip_end(60.0, Some(60.0), Some(50.0), 2.0), 52.0);
+        // A 10 s extra camera in the same clip changes nothing: only the screen and camera 0
+        // bound the clip, the extra camera's layer just disappears past its end.
+        assert_eq!(available_clip_end(30.0, Some(60.0), Some(50.0), 2.0), 30.0);
+        assert_eq!(available_clip_end(30.0, None, None, 0.0), 30.0);
+    }
 
     /// La cadence de lecture, en une phrase : à 24 fps, une seconde réelle doit adopter 24
     /// frames et pas une de plus. Le bug d'origine (un pas fixe de 1/60 s, une frame par
diff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgsl
index 1916cef1f..6d745cd13 100644
--- a/crates/compositor/src/vk_shaders/layer.wgsl
+++ b/crates/compositor/src/vk_shaders/layer.wgsl
@@ -41,6 +41,8 @@ struct Layer {
     trail_b: vec4<f32>,   // mode 8 : coins BR, BL du plan a la frame precedente (comme src_prev) ; mode 18 incline : en fractions de sortie
     trail_mb: vec4<f32>,  // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; mode 18 incline : le `mb` du mode 8 (profondeur de champ), et `color.xy` sa lampe ; 0 ailleurs
     cover: vec4<f32>,     // x = desk-view cover 0..1, y = blur radius (quad px), z = dim, w unused
+    persp: array<vec4<f32>, 3>, // mode 0: rows of the homography quad point (0..1 in dst) -> camera uv (0..1 of the valid frame), xyz; read when layer_fx.y = 1
+    layer_fx: vec4<f32>,  // x = transparency 0..1 (0 = opaque), every mode; y = 1 when persp applies; z, w unused
 }
 
 @group(0) @binding(0) var<uniform> layer: Layer;
@@ -588,6 +590,18 @@ fn blur_webcam_bg(uv: vec2<f32>, intensity: f32, qpx: vec2<f32>, local_px: vec2<
     return blur_webcam_radius(uv, max(intensity, 0.0) * 22.0 + 1.5, qpx, local_px, valid);
 }
 
+// Camera homography (`persp`, read when `layer_fx.y` = 1): the camera point (0..1 of its valid
+// frame) seen at `local` (0..1 in the layer's dst quad), and in z whether there is one -- 0 when
+// the point is behind the projection (q.z <= 0) or outside the camera frame, where the layer is
+// transparent. Mirror of the HLSL and MSL `persp_camera`.
+fn persp_camera(local: vec2<f32>) -> vec3<f32> {
+    let p = vec3<f32>(local, 1.0);
+    let q = vec3<f32>(dot(layer.persp[0].xyz, p), dot(layer.persp[1].xyz, p), dot(layer.persp[2].xyz, p));
+    let cam = q.xy / max(q.z, 1e-6);
+    let inside = q.z > 0.0 && all(cam >= vec2<f32>(0.0)) && all(cam <= vec2<f32>(1.0));
+    return vec3<f32>(cam, select(0.0, 1.0, inside));
+}
+
 // ---- Curseur MODELISE (mode 15) ----
 // Port ligne pour ligne de `cursor_model` (HLSL), dont les commentaires font foi : un curseur
 // SCULPTE (`trail_a.x` > 0, la fleche ou la main d'un des cinq themes d'origine modelee en
@@ -2265,12 +2279,14 @@ fn device_frame(local: vec2<f32>) -> vec4<f32> {
     return vec4<f32>(rgb * a, a); // premultiplie
 }
 
-@fragment
-fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
+// The body of `fs_main`, which only adds the layer's transparency on top of it.
+fn fs_layer(i: VsOut) -> vec4<f32> {
     var rgb: vec3<f32>;
     var alpha: f32;
     // 1 sauf en detourage, ou il porte le masque du sujet. Cf. la branche fx.z plus bas.
     var alpha_mask = 1.0;
+    // 0 where a camera homography finds no camera point (`persp_camera`), 1 everywhere else.
+    var persp_keep = 1.0;
 
     if layer.mode < 0.5 {
         // Mode 0 — vidéo NV12 + flou de mouvement par vélocité (§8), port 1:1 du
@@ -2280,18 +2296,31 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
         // du calque sans avoir à transporter un champ de vitesse.
         let taps = i32(layer.mb.x);
         let mb_scale = clamp(layer.mb.y, 0.0, 1.0);
+        var uv_now = i.uv;
+        if layer.layer_fx.y > 0.5 {
+            // Camera homography: the texture uv comes from the fragment's place in the quad
+            // (`src` is not used), scaled to the valid part of the decoder texture.
+            let cam = persp_camera((i.pout - layer.dst.xy) / layer.dst.zw);
+            persp_keep = cam.z;
+            uv_now = cam.xy * layer.fx.xy;
+        }
         // `taps` d'abord : un draw qui a oublié `dst_prev` le laisse à zéro, et
         // la division par `dst_prev.zw` produirait des UV infinis. Dégrader vers
         // le chemin net est le seul échec acceptable pour un effet cosmétique.
         if taps <= 1 || mb_scale <= 0.001 || layer.dst_prev.z <= 0.0 || layer.dst_prev.w <= 0.0 {
-            rgb = sample_yuv(i.uv);
+            rgb = sample_yuv(uv_now);
         } else {
             let localp = (i.pout - layer.dst_prev.xy) / layer.dst_prev.zw;
-            let uv_prev = layer.src_prev.xy + localp * (layer.src_prev.zw - layer.src_prev.xy);
-            let duv = i.uv - uv_prev;
+            var uv_prev = layer.src_prev.xy + localp * (layer.src_prev.zw - layer.src_prev.xy);
+            if layer.layer_fx.y > 0.5 {
+                // The previous frame's uv is the same map at the quad's previous place.
+                let cam_prev = persp_camera(localp);
+                uv_prev = select(uv_now, cam_prev.xy * layer.fx.xy, cam_prev.z > 0.5);
+            }
+            let duv = uv_now - uv_prev;
             let duv_blur = duv * mb_scale;
             if dot(duv_blur, duv_blur) < 1e-9 {
-                rgb = sample_yuv(i.uv);
+                rgb = sample_yuv(uv_now);
             } else {
                 // Borne 16 en dur, identique au HLSL et au MSL : `taps` vient d'un
                 // uniform et une boucle sans borne statique ne se déroule pas.
@@ -2301,7 +2330,7 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
                 let step = 1.0 / f32(taps - 1);
                 for (var k: i32 = 0; k < 16; k = k + 1) {
                     if k >= taps { break; }
-                    acc = acc + sample_yuv(i.uv - duv_blur * (1.0 - f32(k) * step));
+                    acc = acc + sample_yuv(uv_now - duv_blur * (1.0 - f32(k) * step));
                 }
                 rgb = acc / f32(taps);
             }
@@ -2312,12 +2341,12 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
         // l'etendue valide de la texture webcam pour ramener uv dans l'espace du masque.
         let effect = layer.fx.z;
         if effect > 0.5 {
-            let mask_uv = i.uv / max(layer.fx.xy, vec2<f32>(1e-6));
+            let mask_uv = uv_now / max(layer.fx.xy, vec2<f32>(1e-6));
             let person = clamp(textureSample(texMask, samp, mask_uv).r, 0.0, 1.0);
             if effect > 2.5 {
                 rgb = mix(layer.color.rgb, rgb, person);
             } else if effect > 1.5 {
-                rgb = mix(blur_webcam_bg(i.uv, layer.fx.w, layer.quad_px, i.local, layer.fx.xy), rgb, person);
+                rgb = mix(blur_webcam_bg(uv_now, layer.fx.w, layer.quad_px, i.local, layer.fx.xy), rgb, person);
             } else {
                 alpha_mask = person;
             }
@@ -2326,7 +2355,7 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
         // Desk-view cover: the camera is being tilted, so the whole picture is blurred and
         // dimmed (cover.x = strength, cover.y = radius in quad px, cover.z = dim at full cover).
         if layer.cover.x > 0.001 {
-            let hidden = blur_webcam_radius(i.uv, layer.cover.y, layer.quad_px, i.local, layer.fx.xy);
+            let hidden = blur_webcam_radius(uv_now, layer.cover.y, layer.quad_px, i.local, layer.fx.xy);
             rgb = mix(rgb, hidden, layer.cover.x) * (1.0 - layer.cover.z * layer.cover.x);
         }
     } else if layer.mode < 1.5 {
@@ -2701,7 +2730,7 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
     if layer.mode > 4.5 && layer.mode < 5.5 {
         base_alpha = 1.0;
     }
-    alpha = base_alpha * alpha_mask;
+    alpha = base_alpha * alpha_mask * persp_keep;
 
     if layer.radius_px > 0.0 {
         // Feather ~1.5 px sur le bord du quad — parité exacte avec le HLSL
@@ -2724,3 +2753,9 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
 
     return vec4<f32>(rgb * alpha, alpha); // alpha prémultiplié
 }
+
+@fragment
+fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
+    // Premultiplied, so the transparency scales all four channels; 0 leaves them as they are.
+    return fs_layer(i) * (1.0 - layer.layer_fx.x);
+}
diff --git a/crates/compositor/tests/compose_linux.rs b/crates/compositor/tests/compose_linux.rs
index c8bc45936..1c74e011e 100644
--- a/crates/compositor/tests/compose_linux.rs
+++ b/crates/compositor/tests/compose_linux.rs
@@ -799,6 +799,7 @@ fn export_linux_mp4() {
         source_end_sec: 1.0,
         webcam_offset_sec: 0.0,
         has_audio: true,
+        additional_cameras: Vec::new(),
     }];
     let params = ExportParams {
         width: 640,
diff --git a/crates/compositor/tests/export_timing.rs b/crates/compositor/tests/export_timing.rs
index 34d5e8de4..adb90bb43 100644
--- a/crates/compositor/tests/export_timing.rs
+++ b/crates/compositor/tests/export_timing.rs
@@ -117,6 +117,7 @@ fn whole_clip(dir: &PathBuf) -> ClipSource {
         source_end_sec: SOURCE_SEC,
         webcam_offset_sec: 0.0,
         has_audio: false,
+        additional_cameras: Vec::new(),
     }
 }
 
diff --git a/crates/poc-d3d/src/bench.rs b/crates/poc-d3d/src/bench.rs
index 3da91883b..2b657b91a 100644
--- a/crates/poc-d3d/src/bench.rs
+++ b/crates/poc-d3d/src/bench.rs
@@ -154,6 +154,7 @@ fn run_bench(args: &[String]) -> Result<()> {
                 source_end_sec: 6.0, // la fixture entière (§ fixture.json : 6 s, 360 frames)
                 webcam_offset_sec: 0.0,
                 has_audio: false,
+                additional_cameras: Vec::new(),
             };
             let path = format!("{out}/{}_{:?}.mp4", cfg.name, backend).to_lowercase();
             let s = pipeline::run_composited_multi(
@@ -296,6 +297,7 @@ fn run_gif_bench(
         source_end_sec: f64::MAX,
         webcam_offset_sec: 0.0,
         has_audio: false,
+        additional_cameras: Vec::new(),
     }];
     for r in 0..repeat {
         // Each run writes to the same path — the last frame wins. The
diff --git a/electron/ai-edition/agent-tools.test.ts b/electron/ai-edition/agent-tools.test.ts
index fc8ba4085..f612c92eb 100644
--- a/electron/ai-edition/agent-tools.test.ts
+++ b/electron/ai-edition/agent-tools.test.ts
@@ -1211,6 +1211,96 @@ describe("a full-camera region needs a camera", () => {
 	});
 });
 
+describe("full-camera regions and layout sections share one lane", () => {
+	/** A side-by-side section of cameras 1 and 2 over 10–15 s of clip_1. */
+	function withLayoutSection(document: AxcutDocument): AxcutDocument {
+		return documentSchema.parse({
+			...document,
+			legacyEditor: {
+				...((document.legacyEditor as Record<string, unknown>) ?? {}),
+				cameraLayoutRegions: [
+					{
+						id: "camlayout_1",
+						startMs: 10_000,
+						endMs: 15_000,
+						clipId: "clip_1",
+						assetId: "asset_1",
+						sourceStartSec: 10,
+						sourceEndSec: 15,
+						template: "side-by-side",
+						slots: [{ camera: 0 }, { camera: 1 }],
+					},
+				],
+			},
+		});
+	}
+
+	it("exposes layout sections read-only in the snapshot", () => {
+		const document = withLayoutSection(withCameraTrack(fixtureDocument()));
+		const snapshot = JSON.parse(executeAgentTool(document, "getCurrentDocument", "").resultJson);
+		expect(snapshot.cameraLayoutRegions).toEqual([
+			{ id: "camlayout_1", startSec: 10, endSec: 15, template: "side-by-side", cameras: [1, 2] },
+		]);
+		expect(snapshot.cameraLayoutNote).toMatch(/read-only/);
+		expect(snapshot.timeBaseNote).toMatch(/cameraLayoutRegions/);
+	});
+
+	it("an empty project reports no layout sections", () => {
+		const snapshot = JSON.parse(
+			executeAgentTool(fixtureDocument(), "getCurrentDocument", "").resultJson,
+		);
+		expect(snapshot.cameraLayoutRegions).toEqual([]);
+	});
+
+	it("refuses to add a full-camera region over a layout section", () => {
+		const document = withLayoutSection(withCameraTrack(fixtureDocument()));
+		const result = executeAgentTool(
+			document,
+			"addCameraFullscreen",
+			JSON.stringify({ startSec: 12, endSec: 18 }),
+		);
+		expect(result.ok).toBe(false);
+		expect(result.document).toBeUndefined();
+		const error = JSON.parse(result.resultJson).error as string;
+		expect(error).toMatch(/camlayout_1/);
+		expect(error).toMatch(/side-by-side, 10–15 s/);
+		expect(error).toMatch(/may not overlap/);
+	});
+
+	it("allows a full-camera region that only touches a layout section", () => {
+		const document = withLayoutSection(withCameraTrack(fixtureDocument()));
+		const result = executeAgentTool(
+			document,
+			"addCameraFullscreen",
+			JSON.stringify({ startSec: 5, endSec: 10 }),
+		);
+		expect(result.ok).toBe(true);
+	});
+
+	it("refuses to move a full-camera region onto a layout section", () => {
+		const document = withLayoutSection(withCameraTrack(fixtureDocument()));
+		const added = executeAgentTool(
+			document,
+			"addCameraFullscreen",
+			JSON.stringify({ startSec: 0, endSec: 5 }),
+		);
+		expect(added.ok).toBe(true);
+		const regionId = (
+			(added.document?.legacyEditor as Record<string, unknown>).cameraFullscreenRegions as Array<{
+				id: string;
+			}>
+		)[0].id;
+		const moved = executeAgentTool(
+			added.document as AxcutDocument,
+			"setCameraFullscreen",
+			JSON.stringify({ cameraFullscreenId: regionId, startSec: 8, endSec: 11 }),
+		);
+		expect(moved.ok).toBe(false);
+		expect(moved.document).toBeUndefined();
+		expect(JSON.parse(moved.resultJson).error).toMatch(/camlayout_1/);
+	});
+});
+
 // ── D-DESTRUCT ──────────────────────────────────────────────────────────────
 //
 // "Swap the two clips: put the demo first." There was no tool for it — while
diff --git a/electron/ai-edition/agent-tools.ts b/electron/ai-edition/agent-tools.ts
index 3ffc9b215..efc2444d8 100644
--- a/electron/ai-edition/agent-tools.ts
+++ b/electron/ai-edition/agent-tools.ts
@@ -57,6 +57,10 @@ import {
 	effectiveZoomScale,
 	ZOOM_DEPTH_LEGEND,
 } from "../../src/lib/ai-edition/timeline/zoom-scale";
+import {
+	cameraSectionsOverlapping,
+	normalizeCameraLayoutRegions,
+} from "../../src/lib/cameraLayouts";
 import { SETTING_BOUNDS } from "../../src/lib/projectDefaults";
 
 export interface AgentToolExecution {
@@ -97,6 +101,10 @@ function modifierIds(document: AxcutDocument, kind: ModifierKind): string[] {
 			return ((legacy.cameraFullscreenRegions as Array<{ id: string }> | undefined) ?? []).map(
 				(region) => region.id,
 			);
+		case "cameraLayout":
+			return ((legacy.cameraLayoutRegions as Array<{ id: string }> | undefined) ?? []).map(
+				(region) => region.id,
+			);
 		case "audio":
 			// Fragments of one user-visible track share `trackId` and render as a single pill,
 			// so the id that disappears is the group key once, not one per fragment.
@@ -265,6 +273,39 @@ function noCameraUnderSpan(
 	);
 }
 
+/** The editor's file the agent reads layout sections from, coalesced to the pills the ruler draws. */
+function cameraLayoutPillsForAgent(document: AxcutDocument) {
+	const legacy = document.legacyEditor as Record<string, unknown> | null;
+	return coalesceForAgent(normalizeCameraLayoutRegions(legacy?.cameraLayoutRegions));
+}
+
+/**
+ * Refuse a full-camera region that would land on a camera layout section. Both share one
+ * lane on the timeline and may never overlap (the editor refuses the same add as
+ * "occupied"); two overlapping sections would leave the scene to drop one of them.
+ * Layout sections are not editable from here, so the message names the one in the way.
+ */
+function cameraLayoutInTheWay(
+	document: AxcutDocument,
+	startSec: number,
+	endSec: number,
+): AgentToolExecution | null {
+	const blocking = cameraSectionsOverlapping(
+		cameraLayoutPillsForAgent(document),
+		toMs(startSec),
+		toMs(endSec),
+	)[0];
+	if (!blocking) return null;
+	return failure(
+		`The span ${startSec.toFixed(1)}–${endSec.toFixed(1)} s overlaps the camera layout ` +
+			`section ${blocking.id} (${blocking.template}, ${roundSec(blocking.startMs)}–` +
+			`${roundSec(blocking.endMs)} s), so no full-camera region was written. Full-camera ` +
+			"regions and layout sections share one camera lane and may not overlap. Pick a span " +
+			"outside every entry of cameraLayoutRegions in getCurrentDocument, or ask the user " +
+			"to change the layout section in the editor.",
+	);
+}
+
 /** The span the edited timeline actually occupies, for an actionable refusal. */
 function editedExtentSec(document: AxcutDocument): { startSec: number; endSec: number } {
 	const clips = document.timeline.clips;
@@ -335,18 +376,21 @@ function landingSuffix(
 	return parts.length ? ` (${parts.join(", ")})` : "";
 }
 
-/** Ids of every modifier in the document, all four families at once — the basis
+/** Ids of every modifier in the document, every family at once — the basis
  * for naming what a destructive edit took with it. */
 function modifierIdsOf(document: AxcutDocument): string[] {
 	const legacy = (document.legacyEditor as Record<string, unknown>) ?? {};
 	const speedRegions = (legacy.speedRegions as Array<{ id: string }> | undefined) ?? [];
 	const cameraFullscreenRegions =
 		(legacy.cameraFullscreenRegions as Array<{ id: string }> | undefined) ?? [];
+	const cameraLayoutRegions =
+		(legacy.cameraLayoutRegions as Array<{ id: string }> | undefined) ?? [];
 	return [
 		...document.zoomRanges.map((r) => r.id),
 		...document.annotations.map((r) => r.id),
 		...speedRegions.map((r) => r.id),
 		...cameraFullscreenRegions.map((r) => r.id),
+		...cameraLayoutRegions.map((r) => r.id),
 	];
 }
 
@@ -758,7 +802,11 @@ export function documentSnapshotForModel(
 	const autoFocusAll = legacy?.autoFocusAll === true;
 	return {
 		timeBaseNote:
-			"clips and trims are in source-time seconds; zooms, speedRegions, annotations, cameraFullscreenRegions and audioTracks are in virtual (edited-timeline) seconds.",
+			"clips and trims are in source-time seconds; zooms, speedRegions, annotations, cameraFullscreenRegions, cameraLayoutRegions and audioTracks are in virtual (edited-timeline) seconds.",
+		cameraLayoutNote:
+			"cameraLayoutRegions are multi-camera layout sections the user placed in the editor; they are read-only here. " +
+			"They share one camera lane with cameraFullscreenRegions and the two may never overlap, so addCameraFullscreen / setCameraFullscreen refuse a span that lands on one. " +
+			"cameras lists the cameras shown, in place order, numbered as the user sees them (1 = the recording's main webcam).",
 		audioNote:
 			"audioTracks are imported voiceover / music files laid over the recording. They are clip-anchored like every other region, so they travel with their clip through reorder and trim, and they play at 1x whatever a speed region does to the picture under them. addAudio places an EXISTING asset of kind 'audio'; nothing here can import a file from disk or record one, so if the project has no audio asset, say so rather than inventing an id.",
 		zoomNote:
@@ -854,6 +902,13 @@ export function documentSnapshotForModel(
 			startSec: roundSec(c.startMs),
 			endSec: roundSec(c.endMs),
 		})),
+		cameraLayoutRegions: cameraLayoutPillsForAgent(document).map((l) => ({
+			id: l.id,
+			startSec: roundSec(l.startMs),
+			endSec: roundSec(l.endMs),
+			template: l.template,
+			cameras: l.slots.map((slot) => slot.camera + 1),
+		})),
 		// Imported audio, collapsed to the pills the ruler draws — a track ventilated
 		// across a clip boundary is several fragments the user sees as one thing, and
 		// the model has to name what the user sees.
@@ -2034,6 +2089,8 @@ export function executeAgentTool(
 			}
 			const blind = noCameraUnderSpan(document, landing.startSec, landing.endSec);
 			if (blind) return blind;
+			const occupied = cameraLayoutInTheWay(document, landing.startSec, landing.endSec);
+			if (occupied) return occupied;
 			const next: AxcutDocument = {
 				...document,
 				legacyEditor: { ...legacy, cameraFullscreenRegions: [...prev, ...placed] },
@@ -2078,6 +2135,8 @@ export function executeAgentTool(
 			}
 			const blindMove = noCameraUnderSpan(document, landing.startSec, landing.endSec);
 			if (blindMove) return blindMove;
+			const occupiedMove = cameraLayoutInTheWay(document, landing.startSec, landing.endSec);
+			if (occupiedMove) return occupiedMove;
 			const next: AxcutDocument = {
 				...document,
 				legacyEditor: { ...legacy, cameraFullscreenRegions: rebuiltCamera },
diff --git a/electron/ai-edition/deep-agent/service.ts b/electron/ai-edition/deep-agent/service.ts
index 21f5b79a5..90a1b815f 100644
--- a/electron/ai-edition/deep-agent/service.ts
+++ b/electron/ai-edition/deep-agent/service.ts
@@ -177,9 +177,9 @@ export const TOOL_DESCRIPTIONS: Record<string, string> = {
 	setAnnotation:
 		"Move, resize, or edit the text of an existing annotation by id (virtual-timeline seconds). Only the fields you pass are changed.",
 	addCameraFullscreen:
-		"Add a camera-fullscreen region over a span of the edited timeline (virtual seconds): the webcam fills the frame for that span. This only does something when the footage under that span comes from an asset with a linked webcam — check assets[].hasCameraTrack (or hasAnyCamera) in getCurrentDocument first. On footage with no camera the call is refused rather than storing a region that would render nothing; say so instead of retrying.",
+		"Add a camera-fullscreen region over a span of the edited timeline (virtual seconds): the webcam fills the frame for that span. This only does something when the footage under that span comes from an asset with a linked webcam — check assets[].hasCameraTrack (or hasAnyCamera) in getCurrentDocument first. On footage with no camera the call is refused rather than storing a region that would render nothing; say so instead of retrying. It is also refused over a multi-camera layout section (cameraLayoutRegions): the two share one lane and may not overlap.",
 	setCameraFullscreen:
-		"Move or resize an existing camera-fullscreen region by id (virtual-timeline seconds). Only the fields you pass are changed. Refused if the new span lands on footage with no linked webcam.",
+		"Move or resize an existing camera-fullscreen region by id (virtual-timeline seconds). Only the fields you pass are changed. Refused if the new span lands on footage with no linked webcam or on a layout section (cameraLayoutRegions).",
 	addAudio:
 		"Lay an ALREADY-IMPORTED audio file over the recording across a span of the edited timeline (virtual seconds): a voiceover, or a music bed. assetId must name an asset whose kind is 'audio' — getCurrentDocument lists them; nothing here can import a file from disk or record one, so if there is none, say so instead of guessing an id. Omit endSec to play the whole file from offsetSec. kind picks the lane ('voiceover' or 'music'). offsetSec is where in the FILE playback starts, gainDb its level (0 unchanged, negative ducks it). A voiceover-lane track is also what gets transcribed, so the lane is not only cosmetic.",
 	setAudio:
diff --git a/electron/ipc/nativeBridge.ts b/electron/ipc/nativeBridge.ts
index 61ed8ef86..82e7c15a1 100644
--- a/electron/ipc/nativeBridge.ts
+++ b/electron/ipc/nativeBridge.ts
@@ -425,6 +425,7 @@ export function registerNativeBridgeHandlers(context: NativeBridgeContext) {
 								request.payload.webcamOffsetSec,
 								request.payload.clipIndex,
 								request.payload.sourceTimeSec,
+								request.payload.additionalCameras ?? [],
 							);
 							return createSuccessResponse(requestId, { ok: true });
 						case "destroyView":
diff --git a/electron/native-bridge/services/compositorViewService.ts b/electron/native-bridge/services/compositorViewService.ts
index 6dbfb1461..550d67dcb 100644
--- a/electron/native-bridge/services/compositorViewService.ts
+++ b/electron/native-bridge/services/compositorViewService.ts
@@ -14,6 +14,7 @@ import type {
 } from "../../../src/native/contracts";
 import type { GifExportJob } from "../../ipc/gifExportJobs";
 import type {
+	ClipCameraInput,
 	ClipInput,
 	CompositorBackend,
 	CompositorParamValue,
@@ -775,12 +776,21 @@ export class CompositorViewService {
 		webcamOffsetSec: number,
 		clipIndex: number,
 		sourceTimeSec: number,
+		additionalCameras: ClipCameraInput[] = [],
 	): void {
 		const addon = this.ensureAddon();
 		if (!addon) {
 			return;
 		}
-		addon.setActiveClip(id, screenPath, webcamPath, webcamOffsetSec, clipIndex, sourceTimeSec);
+		addon.setActiveClip(
+			id,
+			screenPath,
+			webcamPath,
+			webcamOffsetSec,
+			clipIndex,
+			sourceTimeSec,
+			additionalCameras,
+		);
 	}
 
 	destroyView(id: number): void {
diff --git a/electron/native/compositor-view/addon.d.ts b/electron/native/compositor-view/addon.d.ts
index e87b830b5..cbc1b8d79 100644
--- a/electron/native/compositor-view/addon.d.ts
+++ b/electron/native/compositor-view/addon.d.ts
@@ -118,6 +118,14 @@ export interface ExportParamsInput {
 	bitrate?: number;
 }
 
+/** An additional camera (2-4) of a clip, for `setActiveClip` and the export clip list.
+ *  = napi `ClipCameraInput`. */
+export interface ClipCameraInput {
+	path: string;
+	/** Camera source time = screen source time - this. */
+	offsetSec: number;
+}
+
 /** One timeline clip for the native multiclip export (screen + webcam files + source trim). */
 export interface ClipInput {
 	screenPath: string;
@@ -126,6 +134,8 @@ export interface ClipInput {
 	sourceEndSec: number;
 	/** webcam source time = screen source time − this. */
 	webcamOffsetSec: number;
+	/** Cameras 2-4 (index k-1 = camera k). Only those a layout region shows are decoded. */
+	additionalCameras?: ClipCameraInput[];
 }
 
 /** Which backend the compositor will run on. `"cpu"` = WARP rasterisation + software
@@ -198,6 +208,8 @@ export interface CompositorViewAddon {
 	/** Installs the app scene (JSON `SceneDescription`) — layout preset etc. drive the render
 	 *  instead of the fixture. Invalid JSON is ignored native-side. */
 	setScene(id: number, sceneJson: string): void;
+	/** `additionalCameras`: cameras 2-4 of the clip (index k-1 = camera k, empty `path` = none).
+	 *  An addon built before it ignores the argument. */
 	setActiveClip(
 		id: number,
 		screenPath: string,
@@ -205,6 +217,7 @@ export interface CompositorViewAddon {
 		webcamOffsetSec: number,
 		clipIndex: number,
 		sourceTimeSec: number,
+		additionalCameras?: ClipCameraInput[],
 	): void;
 	destroyView(id: number): void;
 	/** Renders the fixture to `outPath` (C8), auto-pausing live previews. `onProgress`
diff --git a/package-lock.json b/package-lock.json
index 3f8dceacc..638a465bf 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -37,6 +37,7 @@
 				"clsx": "^2.1.1",
 				"electron-updater": "^6.8.9",
 				"i18next": "^23.16.0",
+				"js-aruco2": "2.0.0",
 				"langchain": "^1.2.39",
 				"lucide-react": "^0.545.0",
 				"mediabunny": "^1.40.1",
@@ -8316,6 +8317,15 @@
 				"url": "https://github.com/sponsors/panva"
 			}
 		},
+		"node_modules/js-aruco2": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/js-aruco2/-/js-aruco2-2.0.0.tgz",
+			"integrity": "sha512-2R9P7INqIkg1fsGBazSDLChmfwJpbaYN26gO6wFr1TLIOrvwQf0YzuhwVZAPF8frQ4cjdppAN0dRmExEd/6wqw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12.0.0"
+			}
+		},
 		"node_modules/js-tiktoken": {
 			"version": "1.0.21",
 			"resolved": "https://registry.npmjs.org/js-tiktoken/-/js-tiktoken-1.0.21.tgz",
diff --git a/package.json b/package.json
index f707b8dbc..2cc3c0e42 100644
--- a/package.json
+++ b/package.json
@@ -125,6 +125,7 @@
 		"clsx": "^2.1.1",
 		"electron-updater": "^6.8.9",
 		"i18next": "^23.16.0",
+		"js-aruco2": "2.0.0",
 		"langchain": "^1.2.39",
 		"lucide-react": "^0.545.0",
 		"mediabunny": "^1.40.1",
diff --git a/scripts/editor-multicam-smoke.mjs b/scripts/editor-multicam-smoke.mjs
new file mode 100644
index 000000000..33222c6c3
--- /dev/null
+++ b/scripts/editor-multicam-smoke.mjs
@@ -0,0 +1,592 @@
+// Multi-camera editor smoke run (dev tool, not part of any test suite).
+//
+// Drives the built Electron app with Playwright through the multi-camera editor: adds a
+// "camera + inset" section from the layout menu, picks its cameras in the inspector, converts
+// a Full Camera section (key C) to "screen + camera" and back, undoes and redoes that, drags
+// a PiP window in the preview, applies a perspective correction in the calibration dialog,
+// saves, relaunches the app and checks the project came back unchanged. After every step it
+// reads the saved project file and asserts the document state, and it captures the live
+// preview inside each section.
+//
+// Preview captures are taken at the middle of a section's VISIBLE span: its span on the ruler
+// minus the trims of its clip. A section eases in and out over its first and last moments, so
+// a capture near either end of what is visible shows the transition, not the layout (a trim
+// that cuts into a section moves its visible start, and the glide with it). The test section
+// is placed clear of the project's trims for the same reason. With camera 1 in the large
+// place, the run also measures the composed frame's outer pixel columns and rows against the
+// wallpaper colour, so a frame that does not fill edge to edge fails.
+//
+// Usage (Windows, from the repo root):
+//   npm run build-vite
+//   npm run build:native:compositor   # then copy compositor_view.node into the bin dir below
+//   node scripts/editor-multicam-smoke.mjs --source <projectId> --out <dir> [--bin <dir>]
+//
+//   --source  id of an existing project with at least two cameras on its first clip
+//             (e.g. proj_7bc8…). It is NOT modified: the run copies it to a new project id
+//             with a fresh `updatedAt`, so the editor opens the copy, and deletes the copy at
+//             the end. Back up %APPDATA%\openscreen\projects first anyway: the editor may
+//             touch other state while it runs.
+//   --out     directory for screenshots, the Electron log and results.json.
+//   --bin     native bin dir holding compositor_view.node and the ffmpeg DLLs
+//             (default electron/native/bin/win32-<arch>).
+//
+// The app is launched with the repo root as its entry (not dist-electron/main.js, which would
+// move userData to Roaming\Electron) and with OPENSCREEN_DISABLE_CONTENT_PROTECTION=1.
+// Exit code 1 when any check failed.
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { _electron as electron } from "playwright";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+function arg(name, fallback) {
+	const i = process.argv.indexOf(`--${name}`);
+	return i >= 0 && process.argv[i + 1] ? process.argv[i + 1] : fallback;
+}
+
+const SOURCE_ID = arg("source");
+const OUT = arg("out");
+const BIN = arg("bin", path.join(ROOT, "electron", "native", "bin", `win32-${process.arch}`));
+if (!SOURCE_ID || !OUT) {
+	console.error("usage: node scripts/editor-multicam-smoke.mjs --source <projectId> --out <dir>");
+	process.exit(2);
+}
+fs.mkdirSync(OUT, { recursive: true });
+
+const PROJECTS = path.join(process.env.APPDATA ?? "", "openscreen", "projects");
+const COPY_ID = `proj_${randomUUID()}`;
+const COPY_FILE = path.join(PROJECTS, `${COPY_ID}.openscreen`);
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const results = [];
+function note(name, ok, detail = "") {
+	results.push({ name, ok, detail });
+	console.log(`${ok ? "PASS" : "FAIL"}  ${name}  ${detail}`);
+}
+
+function readDoc() {
+	return JSON.parse(fs.readFileSync(COPY_FILE, "utf8"));
+}
+function cameraState(doc = readDoc()) {
+	const legacy = doc.legacyEditor ?? {};
+	return {
+		layouts: legacy.cameraLayoutRegions ?? [],
+		fulls: legacy.cameraFullscreenRegions ?? [],
+		settings: legacy.cameraSettings ?? null,
+	};
+}
+// Saves are asynchronous: poll the file until the predicate holds or the time is up.
+async function waitState(predicate, timeoutMs = 8000) {
+	const end = Date.now() + timeoutMs;
+	let state = cameraState();
+	while (Date.now() < end) {
+		state = cameraState();
+		try {
+			if (predicate(state)) return { ok: true, state };
+		} catch {
+			// a half-written state: keep polling
+		}
+		await sleep(200);
+	}
+	return { ok: false, state };
+}
+/**
+ * The part of a camera section the viewer sees, in ruler seconds: its span minus the trims of
+ * its clip (trims are in source seconds; a clip maps source to ruler time by a fixed offset).
+ * The longest remaining piece, or null when a trim hides the whole section.
+ */
+function visibleSpan(row, doc) {
+	const clips = doc.timeline.clips;
+	const clip =
+		clips.find((c) => c.id === row.clipId) ??
+		clips.find(
+			(c) => c.timelineStartSec * 1000 <= row.startMs && row.startMs < c.timelineEndSec * 1000,
+		);
+	let pieces = [[row.startMs / 1000, row.endMs / 1000]];
+	for (const trim of doc.timeline.trimRanges ?? []) {
+		if (!clip || trim.assetId !== clip.assetId) continue;
+		if (trim.clipId && trim.clipId !== clip.id) continue;
+		const offset = clip.timelineStartSec - clip.sourceStartSec;
+		const [cutStart, cutEnd] = [trim.startSec + offset, trim.endSec + offset];
+		pieces = pieces
+			.flatMap(([start, end]) => [
+				[start, Math.min(end, cutStart)],
+				[Math.max(start, cutEnd), end],
+			])
+			.filter(([start, end]) => end - start > 1e-3);
+	}
+	pieces.sort((a, b) => b[1] - b[0] - (a[1] - a[0]));
+	return pieces[0] ?? null;
+}
+/** Where a steady-state capture of a section goes: the middle of its visible span. */
+function steadyMid(row, doc = readDoc()) {
+	const span = visibleSpan(row, doc);
+	return span ? (span[0] + span[1]) / 2 : (row.startMs + row.endMs) / 2000;
+}
+/** The first time from `fromSec` on with `lengthSec` free of the first clip's trims. */
+function clearOfTrims(fromSec, lengthSec, doc = readDoc()) {
+	const clip = doc.timeline.clips[0];
+	const offset = clip.timelineStartSec - clip.sourceStartSec;
+	const trims = [...(doc.timeline.trimRanges ?? [])].sort((a, b) => a.startSec - b.startSec);
+	let at = fromSec;
+	for (const trim of trims) {
+		if (trim.assetId !== clip.assetId || (trim.clipId && trim.clipId !== clip.id)) continue;
+		const [cutStart, cutEnd] = [trim.startSec + offset, trim.endSec + offset];
+		if (at < cutEnd && at + lengthSec > cutStart) at = Math.ceil(cutEnd) + 1;
+	}
+	return at;
+}
+
+const brief = (rows) =>
+	rows
+		.map(
+			(r) =>
+				`${r.template ?? "full"}[${(r.slots ?? []).map((s) => s.camera).join(",")}]@${(
+					r.startMs / 1000
+				).toFixed(2)}-${(r.endMs / 1000).toFixed(2)}`,
+		)
+		.join(" ");
+
+// 1. The copy the editor opens: newest `updatedAt`, fresh id, otherwise the source verbatim.
+const source = JSON.parse(fs.readFileSync(path.join(PROJECTS, `${SOURCE_ID}.openscreen`), "utf8"));
+source.project.id = COPY_ID;
+source.project.title = `Multi-camera smoke ${new Date().toISOString()}`;
+source.project.updatedAt = new Date().toISOString();
+fs.writeFileSync(COPY_FILE, JSON.stringify(source));
+console.log(`copy: ${COPY_FILE}`);
+
+const log = fs.createWriteStream(path.join(OUT, "electron.log"));
+const consoleErrors = [];
+
+async function launch() {
+	const app = await electron.launch({
+		args: [ROOT, "--lang=en-US"],
+		cwd: ROOT,
+		env: {
+			...process.env,
+			OPENSCREEN_COMPOSITOR_VIEW_NODE: path.join(BIN, "compositor_view.node"),
+			OPENSCREEN_DISABLE_CONTENT_PROTECTION: "1",
+			PATH: `${BIN};${process.env.PATH}`,
+		},
+		timeout: 60_000,
+	});
+	const proc = app.process();
+	proc.stdout?.on("data", (d) => log.write(d));
+	proc.stderr?.on("data", (d) => log.write(d));
+	const hud = await app.firstWindow({ timeout: 60_000 });
+	await hud.waitForLoadState("domcontentloaded");
+	// Switching closes the HUD window under the evaluate, so its rejection is expected.
+	await hud.evaluate(() => window.electronAPI.switchToEditor()).catch(() => undefined);
+	let editor = null;
+	for (let i = 0; i < 60 && !editor; i++) {
+		editor = app.windows().find((w) => w.url().includes("windowType=editor")) ?? null;
+		if (!editor) await sleep(500);
+	}
+	if (!editor) throw new Error("editor window did not open");
+	editor.on("console", (m) => m.type() === "error" && consoleErrors.push(m.text()));
+	editor.on("pageerror", (e) => consoleErrors.push(`pageerror: ${e.message}`));
+	await editor.waitForLoadState("domcontentloaded");
+	const preview = editor.getByTestId("preview");
+	await preview.waitFor({ state: "visible", timeout: 30_000 });
+	await sleep(8000); // project load + first composed frame
+	return { app, proc, editor, preview };
+}
+
+async function close({ app, proc }) {
+	await Promise.race([app.close(), sleep(8000)]);
+	try {
+		proc.kill();
+	} catch {
+		// already gone
+	}
+}
+
+function driver(editor, preview) {
+	const time = async () => Number(await preview.getAttribute("data-current-time-sec"));
+	const canvas = editor.locator('[class*="_tlRulerRow_"] [class*="_tlCanvas_"]').first();
+	let totalSec = null;
+	const clickRulerAt = async (frac) => {
+		const box = await canvas.boundingBox();
+		if (!box) throw new Error("no ruler");
+		await editor.mouse.click(box.x + box.width * frac, box.y + box.height / 2);
+		await sleep(400);
+	};
+	// The ruler maps x linearly onto [0, total]; one probe click measures the total.
+	const seekTo = async (sec) => {
+		if (totalSec === null) {
+			await clickRulerAt(0.5);
+			totalSec = (await time()) / 0.5;
+		}
+		await clickRulerAt(sec / totalSec);
+		await sleep(1200); // the compositor's frame for the new time
+		return time();
+	};
+	const xOf = async (sec) => {
+		const box = await canvas.boundingBox();
+		return box.x + (box.width * sec) / totalSec;
+	};
+	// Clicks the camera-lane pill under `sec`: Full Camera and layout sections share that lane.
+	const selectPillAt = async (sec) => {
+		const x = await xOf(sec);
+		const pills = editor.locator('[class*="_lanePill_"][class*="_laneCameraFullscreen_"]');
+		const n = await pills.count();
+		for (let i = 0; i < n; i++) {
+			const b = await pills.nth(i).boundingBox();
+			if (b && x >= b.x && x <= b.x + b.width) {
+				await editor.mouse.click(x, b.y + b.height / 2);
+				await sleep(500);
+				return true;
+			}
+		}
+		return false;
+	};
+	const shot = async (name) => {
+		const file = path.join(OUT, `${name}.png`);
+		await preview.screenshot({ path: file });
+		return file;
+	};
+	const cameraPillCount = () =>
+		editor.locator('[class*="_lanePill_"][class*="_laneCameraFullscreen_"]').count();
+	// The composed frame alone (the preview element also holds the pane around it), decoded in
+	// the page: the four outermost columns and rows on the left and top, each as RGB pixels.
+	const frameEdges = async (name) => {
+		const file = path.join(OUT, `${name}-frame.png`);
+		const png = await preview.locator("canvas").first().screenshot({ path: file });
+		const measured = await editor.evaluate(async (b64) => {
+			const img = new Image();
+			img.src = `data:image/png;base64,${b64}`;
+			await img.decode();
+			const c = document.createElement("canvas");
+			c.width = img.width;
+			c.height = img.height;
+			const g = c.getContext("2d");
+			g.drawImage(img, 0, 0);
+			const px = g.getImageData(0, 0, c.width, c.height).data;
+			const at = (x, y) => {
+				const i = (y * c.width + x) * 4;
+				return [px[i], px[i + 1], px[i + 2]];
+			};
+			const column = (x) => Array.from({ length: c.height }, (_, y) => at(x, y));
+			const row = (y) => Array.from({ length: c.width }, (_, x) => at(x, y));
+			return {
+				size: [c.width, c.height],
+				left: [0, 1, 2, 3].map(column),
+				top: [0, 1, 2, 3].map(row),
+			};
+		}, png.toString("base64"));
+		return { file, ...measured };
+	};
+	return { time, seekTo, selectPillAt, shot, cameraPillCount, frameEdges };
+}
+
+const colourDistance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+const meanColour = (pixels) =>
+	[0, 1, 2].map((k) => Math.round(pixels.reduce((sum, p) => sum + p[k], 0) / pixels.length));
+
+/**
+ * How much wallpaper a frame shows along its left and top edges, measured against a plain
+ * frame (no camera section) where the wallpaper lies at exactly those pixels. Per line (edge
+ * columns 0-3, rows 0-3): the share of its pixels within a small colour distance of the
+ * plain frame's pixel at the same place; the 5 % nearest each corner are left out (rounded
+ * corners). A line that is not part of the picture in the plain frame either (a resampling
+ * seam: it jumps away from its inner neighbour there, while a wallpaper gradient does not) is
+ * reported and skipped.
+ */
+function wallpaperAtEdges(frame, plain) {
+	const report = {};
+	for (const side of ["left", "top"]) {
+		report[side] = frame[side].map((line, i) => {
+			const ref = plain[side][i];
+			const inner = plain[side][i + 1] ?? plain[side][i - 1];
+			const cut = Math.round(line.length * 0.05);
+			const at = Array.from({ length: line.length - 2 * cut }, (_, k) => k + cut);
+			const jump = at.reduce((sum, k) => sum + colourDistance(ref[k], inner[k]), 0) / at.length;
+			const wallpaper = at.filter((k) => colourDistance(line[k], ref[k]) < 24).length;
+			return {
+				line: i,
+				seam: jump > 40,
+				wallpaperShare: Number((wallpaper / at.length).toFixed(3)),
+				mean: meanColour(at.map((k) => line[k])),
+				plainMean: meanColour(at.map((k) => ref[k])),
+			};
+		});
+	}
+	return report;
+}
+
+const shots = [];
+let exitCode = 0;
+let session = null;
+try {
+	session = await launch();
+	const { editor, preview } = session;
+	const d = driver(editor, preview);
+	const before = cameraState();
+	note(
+		"the copy opens with no layout sections",
+		before.layouts.length === 0 && before.fulls.length === 1,
+		`fulls ${brief(before.fulls)}`,
+	);
+	note("one camera-lane pill on open", (await d.cameraPillCount()) === 1);
+
+	// The wallpaper along the frame's edges, read where no section is (the plain screen layout,
+	// whose padding shows the wallpaper). The project's own Full Camera sits at ~17-19 s.
+	const plainAt = clearOfTrims(12, 1);
+	await d.seekTo(plainAt);
+	const plain = await d.frameEdges("0-plain");
+	note("a plain frame is captured as the wallpaper reference", true, `t=${plainAt}`);
+
+	// A. Camera + inset from the layout menu, clear of the project's trims (a trim inside the
+	// section would move its visible start, see the header).
+	const startA = clearOfTrims(3, 2);
+	await d.seekTo(startA);
+	await editor.getByRole("button", { name: /^Add layout/ }).click();
+	await editor.getByRole("button", { name: /Camera \+ inset/ }).click();
+	let r = await waitState(
+		(s) => s.layouts.length === 1 && s.layouts[0].template === "camera-full-pip",
+	);
+	note("A: the layout menu adds a camera-full-pip section", r.ok, brief(r.state.layouts));
+	const sectionA = r.state.layouts[0];
+	const midA = sectionA ? steadyMid(sectionA) : startA + 1;
+	const visibleA = sectionA ? visibleSpan(sectionA, readDoc()) : null;
+	note(
+		"A: the section lies clear of the project's trims",
+		Boolean(visibleA) &&
+			Math.abs(visibleA[0] - sectionA.startMs / 1000) < 1e-3 &&
+			Math.abs(visibleA[1] - sectionA.endMs / 1000) < 1e-3,
+		`visible ${JSON.stringify(visibleA)}, captures at ${midA.toFixed(3)}`,
+	);
+	note(
+		"A: its two places show the clip's two cameras",
+		Boolean(sectionA) &&
+			sectionA.slots.length === 2 &&
+			new Set(sectionA.slots.map((s) => s.camera)).size === 2,
+		JSON.stringify(sectionA?.slots),
+	);
+	const tA = await d.seekTo(midA);
+	shots.push(await d.shot("A-camera-full-pip"));
+	await editor.screenshot({ path: path.join(OUT, "A-window.png") });
+	const boxes = await editor.evaluate(() => {
+		const box = (el) => {
+			const r = el?.getBoundingClientRect();
+			return r ? [r.x, r.y, r.width, r.height].map(Math.round) : null;
+		};
+		const preview = document.querySelector('[data-testid="preview"]');
+		return {
+			window: [window.innerWidth, window.innerHeight],
+			preview: box(preview),
+			frame: box(preview?.querySelector('[class*="_previewFrame_"]')),
+			canvas: box(preview?.querySelector("canvas")),
+		};
+	});
+	fs.writeFileSync(path.join(OUT, "A-boxes.json"), JSON.stringify(boxes, null, 2));
+	note("A: preview captured inside the section", Math.abs(tA - midA) < 0.3, `t=${tA.toFixed(2)}`);
+
+	// B. Choose cameras in the inspector: camera 1 into the large place, then camera 2 again.
+	note("B: the section is selectable on the timeline", await d.selectPillAt(midA));
+	const place1 = editor.getByRole("combobox", { name: /^Place 1/ });
+	await place1.waitFor({ state: "visible", timeout: 5000 });
+	for (const camera of [0, 1]) {
+		await place1.selectOption(String(camera));
+		r = await waitState(
+			(s) =>
+				s.layouts.length === 1 &&
+				s.layouts[0].slots[0].camera === camera &&
+				s.layouts[0].slots[1].camera === 1 - camera,
+		);
+		note(
+			`B: the inspector puts camera ${camera + 1} into place 1 (the other moves to place 2)`,
+			r.ok,
+			JSON.stringify(r.state.layouts[0]?.slots),
+		);
+		// Steady state at the middle of the visible span, captured with nothing selected (the
+		// ruler click clears the selection, so the section is picked again afterwards).
+		await d.seekTo(midA);
+		shots.push(await d.shot(`B-camera${camera + 1}-large`));
+		const edges = wallpaperAtEdges(await d.frameEdges(`B-camera${camera + 1}-large`), plain);
+		fs.writeFileSync(
+			path.join(OUT, `B-camera${camera + 1}-large-edges.json`),
+			JSON.stringify(edges, null, 2),
+		);
+		const lines = [...edges.left, ...edges.top].filter((l) => !l.seam);
+		const describe = (side) =>
+			edges[side]
+				.map((l) => (l.seam ? `${l.line}:seam` : `${l.line}:${l.wallpaperShare}`))
+				.join(" ");
+		note(
+			`B: camera ${camera + 1} large fills the frame edge to edge`,
+			lines.length >= 6 && lines.every((l) => l.wallpaperShare < 0.1),
+			`wallpaper share per line, left ${describe("left")} | top ${describe("top")}`,
+		);
+		await d.selectPillAt(midA);
+		await place1.waitFor({ state: "visible", timeout: 5000 });
+	}
+
+	// C. A Full Camera section (key C) at 9 s, converted to screen + camera and back.
+	await d.seekTo(clearOfTrims(9, 2));
+	await editor.keyboard.press("c");
+	r = await waitState((s) => s.fulls.length === 2);
+	note("C: key C adds a Full Camera section", r.ok, brief(r.state.fulls));
+	const fullC = r.state.fulls.find((f) => f.startMs > 8000 && f.startMs < 10_000);
+	const midC = fullC ? steadyMid(fullC) : 10;
+	await d.seekTo(midC);
+	shots.push(await d.shot("C1-full-camera"));
+	note("C: the Full Camera section is selectable", await d.selectPillAt(midC));
+	const templates = editor.getByRole("group", { name: "Layout" });
+	await templates.getByRole("button", { name: /Screen \+ camera/ }).click();
+	r = await waitState(
+		(s) =>
+			s.fulls.length === 1 &&
+			s.layouts.length === 2 &&
+			s.layouts.some((l) => l.template === "screen-pip" && Math.abs(l.startMs - fullC.startMs) < 1),
+	);
+	note(
+		"C: Full Camera → screen-pip moves the section into the layout list",
+		r.ok,
+		brief(r.state.layouts),
+	);
+	await sleep(1000);
+	shots.push(await d.shot("C2-screen-pip"));
+	await templates.getByRole("button", { name: /^Full camera/ }).click();
+	r = await waitState(
+		(s) =>
+			s.fulls.length === 2 &&
+			s.layouts.length === 1 &&
+			s.fulls.some((f) => Math.abs(f.startMs - fullC.startMs) < 1),
+	);
+	note("C: screen-pip → Full Camera moves it back", r.ok, `fulls ${brief(r.state.fulls)}`);
+	await sleep(1000);
+	shots.push(await d.shot("C3-full-camera-again"));
+
+	// D. Undo and redo the conversion back.
+	await editor.keyboard.press("Control+z");
+	r = await waitState(
+		(s) => s.fulls.length === 1 && s.layouts.some((l) => l.template === "screen-pip"),
+	);
+	note("D: Ctrl+Z restores the screen-pip section", r.ok, brief(r.state.layouts));
+	await editor.keyboard.press("Control+Shift+z");
+	r = await waitState((s) => s.fulls.length === 2 && s.layouts.length === 1);
+	note("D: Ctrl+Shift+Z redoes the Full Camera", r.ok, `fulls ${brief(r.state.fulls)}`);
+
+	// E. Drag the inset window of section A in the preview.
+	await d.seekTo(midA);
+	await d.selectPillAt(midA);
+	const place = editor.getByTestId("layout-place").first();
+	await place.waitFor({ state: "visible", timeout: 5000 });
+	note(
+		"E: the selected section shows its PiP window in the preview",
+		true,
+		`${await editor.getByTestId("layout-place").count()} place(s)`,
+	);
+	const pb = await place.boundingBox();
+	const rectBefore = cameraState().layouts[0]?.slots[1]?.rect ?? null;
+	await editor.mouse.move(pb.x + pb.width / 2, pb.y + pb.height / 2);
+	await editor.mouse.down();
+	for (let i = 1; i <= 10; i++) {
+		await editor.mouse.move(pb.x + pb.width / 2 - 12 * i, pb.y + pb.height / 2 - 6 * i);
+		await sleep(30);
+	}
+	await editor.mouse.up();
+	r = await waitState((s) => {
+		const rect = s.layouts[0]?.slots[1]?.rect;
+		return Boolean(rect) && JSON.stringify(rect) !== JSON.stringify(rectBefore);
+	});
+	note(
+		"E: dragging the PiP window stores its rect",
+		r.ok,
+		JSON.stringify(r.state.layouts[0]?.slots[1]?.rect),
+	);
+	await sleep(1000);
+	shots.push(await d.shot("E-pip-dragged"));
+
+	// F. Calibration: perspective of camera 2, from the camera list.
+	await d.seekTo(midA); // the ruler click also clears the selection
+	const rail = editor.getByRole("button", { name: "Camera layout", exact: true });
+	if ((await rail.getAttribute("aria-pressed")) !== "true") await rail.click();
+	await editor
+		.getByTestId("camera-row-1")
+		.getByRole("button", { name: /Correct perspective/ })
+		.click();
+	const dialog = editor.getByRole("dialog");
+	await dialog.waitFor({ state: "visible", timeout: 5000 });
+	await dialog
+		.getByText(/Loading the camera picture/)
+		.waitFor({ state: "detached", timeout: 15_000 });
+	note(
+		"F: the dialog loads the camera still",
+		!(await dialog.getByText(/could not be loaded/).count()),
+	);
+	await dialog.getByRole("button", { name: "Detect markers" }).click();
+	const status = dialog.getByRole("status");
+	const statusText = (await status.innerText()).trim();
+	note("F: marker detection reports a result", statusText.length > 0, statusText);
+	const h0 = dialog.getByTestId("calibration-handle-0");
+	await h0.focus();
+	for (let i = 0; i < 4; i++) await editor.keyboard.press("Shift+ArrowRight");
+	for (let i = 0; i < 4; i++) await editor.keyboard.press("Shift+ArrowDown");
+	note("F: moving a corner clears the marker message", (await status.innerText()).trim() === "");
+	const h2 = await dialog.getByTestId("calibration-handle-2").boundingBox();
+	await editor.mouse.move(h2.x + h2.width / 2, h2.y + h2.height / 2);
+	await editor.mouse.down();
+	for (let i = 1; i <= 8; i++) {
+		await editor.mouse.move(h2.x + h2.width / 2 - 5 * i, h2.y + h2.height / 2 - 3 * i);
+		await sleep(30);
+	}
+	await editor.mouse.up();
+	await sleep(500);
+	await dialog.screenshot({ path: path.join(OUT, "F1-calibration-dialog.png") });
+	shots.push(path.join(OUT, "F1-calibration-dialog.png"));
+	await dialog.getByRole("button", { name: "Apply", exact: true }).click();
+	r = await waitState((s) => {
+		const p = s.settings?.[1]?.perspective;
+		return Boolean(p) && p.corners.length === 4 && Math.abs(p.aspect - 297 / 210) < 1e-6;
+	});
+	const corners = r.state.settings?.[1]?.perspective?.corners;
+	note(
+		"F: Apply stores camera 2's perspective (A4 landscape)",
+		r.ok && corners[0].x > 0.15 && corners[2].x < 0.85,
+		JSON.stringify(r.state.settings?.[1]?.perspective),
+	);
+	await d.seekTo(midA);
+	await sleep(1000);
+	shots.push(await d.shot("F2-perspective-in-section"));
+
+	// G. Save, relaunch, compare.
+	await editor.keyboard.press("Control+s");
+	await sleep(1500);
+	const saved = cameraState();
+	await close(session);
+	session = null;
+
+	session = await launch();
+	const d2 = driver(session.editor, session.preview);
+	const reopened = cameraState();
+	note(
+		"G: the reopened project keeps sections and camera settings",
+		JSON.stringify(reopened) === JSON.stringify(saved),
+		`${reopened.layouts.length} layout(s), ${reopened.fulls.length} full camera(s)`,
+	);
+	note("G: the timeline shows all three camera sections", (await d2.cameraPillCount()) === 3);
+	await d2.seekTo(midA);
+	shots.push(await d2.shot("G-reopened-section-A"));
+	await d2.seekTo(midC);
+	shots.push(await d2.shot("G-reopened-full-camera"));
+	fs.writeFileSync(path.join(OUT, "final-state.json"), JSON.stringify(reopened, null, 2));
+} catch (error) {
+	note("run completed without an exception", false, String(error?.stack ?? error));
+} finally {
+	note(
+		"no console errors in the editor",
+		consoleErrors.length === 0,
+		consoleErrors.slice(0, 5).join(" | "),
+	);
+	if (session) await close(session);
+	log.end();
+	fs.rmSync(COPY_FILE, { force: true });
+	console.log(`removed copy: ${!fs.existsSync(COPY_FILE)}`);
+	fs.writeFileSync(path.join(OUT, "results.json"), JSON.stringify({ results, shots }, null, 2));
+	exitCode = results.every((x) => x.ok) ? 0 : 1;
+}
+process.exit(exitCode);
diff --git a/scripts/multicam-fixture.mjs b/scripts/multicam-fixture.mjs
new file mode 100644
index 000000000..ac5b460fe
--- /dev/null
+++ b/scripts/multicam-fixture.mjs
@@ -0,0 +1,933 @@
+// Several cameras in the picture, measured end to end (dev tool, not part of the build).
+//
+// Generates synthetic sources and two projects, runs the real headless export, and checks the
+// exported pixels against the camera layout templates and the glide the compositor plans.
+//
+//   node scripts/multicam-fixture.mjs generate <dir>
+//       screen.mp4 (1920x1080 dark grey, 8 s), cam0.mp4 (solid red), cam1.mp4 (solid green),
+//       cam2.mp4 (a 16x9 checkerboard warped "in perspective" onto known corners), all
+//       1280x720, plus multicam.openscreen (three cameras, four layout regions, a perspective
+//       on camera 2) and onecam.openscreen (the same take with camera 1 only, no regions).
+//       Also board43.mp4 (a 12x9 board, 4:3, warped onto the same corners) and two more
+//       projects: persp.openscreen (camera 1 IS that board with a 4:3 perspective, in its
+//       default PiP and then in a Full Camera section) and seam.openscreen (a camera-1 Full
+//       Camera section directly followed by a camera-full-pip [2, 1] layout region).
+//   node scripts/multicam-fixture.mjs export <project.openscreen> <out.mp4>
+//       Runs `electron . export` and prints the wall-clock time. Run from a built tree
+//       (`npm run build-vite`) with OPENSCREEN_COMPOSITOR_VIEW_NODE pointing at the addon and
+//       its ffmpeg DLLs first on PATH.
+//   node scripts/multicam-fixture.mjs check <out.mp4> [multicam|persp|seam]
+//       Extracts frames by index and prints a pass/fail table; exits 1 on any failure.
+//       The project defaults to multicam.
+//
+// The expected rects (`pipRect`, `regionLayers`, `plannedRects`) MIRROR the templates and
+// the planner; they are not an independent derivation. The template PiPs anchor on camera
+// 1's default PiP, which the check measures (red box at 0.5 s) instead of recomputing it.
+//
+// ffmpeg: OPENSCREEN_FFMPEG, else the vendored build under crates/thirdparty.
+
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
+const FFMPEG =
+	process.env.OPENSCREEN_FFMPEG ??
+	path.join(ROOT, "crates", "thirdparty", "ffmpeg-n8.1.2-win64-lgpl-shared", "bin", "ffmpeg.exe");
+
+const DURATION_S = 8;
+const CAM_W = 1280;
+const CAM_H = 720;
+const SQUARE_PX = 80; // 16 x 9 squares on the 1280x720 board
+// Where the board's corners land in camera 2's picture (pixels): TL, TR, BR, BL.
+const BOARD_CORNERS_PX = [
+	[160, 90],
+	[1050, 40],
+	[1180, 680],
+	[70, 600],
+];
+const BOARD_ASPECT = CAM_W / CAM_H;
+// Camera 1's board in persp.openscreen: 12 x 9 squares, so its corrected picture is 4:3 while
+// the camera's own frame is 16:9 — a box laid out from the raw camera would stretch it.
+const BOARD43 = { cols: 12, rows: 9, aspect: 4 / 3 };
+
+// Mirrors src/lib/cameraLayoutTemplates.ts.
+const PIP_WIDTH_FRAC = 0.22;
+const PIP_MARGIN_FRAC = 0.025;
+const PIP_GAP_FRAC = 0.02;
+// Mirrors crates/compositor/src/regions.rs.
+const TRANSITION_WINDOW_S = 1.01505;
+const FULLSCREEN_LEAD_OUT_WINDOW_S = TRANSITION_WINDOW_S * 1.5;
+const EXPORT_FPS = 60;
+const TOLERANCE_PX = 2;
+
+const PERSP_REGIONS = [
+	{ id: "lay_persp_full", startMs: 3000, endMs: 6000, template: "camera-full", cameras: [0] },
+];
+const SEAM_REGIONS = [
+	{ id: "lay_seam_full", startMs: 1000, endMs: 3000, template: "camera-full", cameras: [0] },
+	{ id: "lay_seam_pip", startMs: 3000, endMs: 5000, template: "camera-full-pip", cameras: [1, 0] },
+];
+
+const REGIONS = [
+	{ id: "lay_screen_pip", startMs: 1000, endMs: 3000, template: "screen-pip", cameras: [0, 1] },
+	{ id: "lay_full_pip", startMs: 3000, endMs: 5000, template: "camera-full-pip", cameras: [1, 0] },
+	{ id: "lay_side", startMs: 5500, endMs: 7000, template: "side-by-side", cameras: [0, 1] },
+	{ id: "lay_board", startMs: 7000, endMs: 8000, template: "camera-full", cameras: [2] },
+];
+
+function run(cmd, args) {
+	const result = spawnSync(cmd, args, { encoding: "utf8", maxBuffer: 1 << 28 });
+	if (result.status !== 0) {
+		throw new Error(
+			`${path.basename(cmd)} failed (${result.status}): ${result.stderr?.slice(-2000)}`,
+		);
+	}
+	return result;
+}
+
+function encode(input, filter, out) {
+	run(FFMPEG, [
+		"-y",
+		"-hide_banner",
+		"-loglevel",
+		"error",
+		"-f",
+		"lavfi",
+		"-i",
+		input,
+		...(filter ? ["-vf", filter] : []),
+		"-t",
+		String(DURATION_S),
+		"-pix_fmt",
+		"yuv420p",
+		"-c:v",
+		"libopenh264",
+		"-b:v",
+		"12M",
+		out,
+	]);
+}
+
+/** Unit square (0,0),(1,0),(1,1),(0,1) onto four points (Heckbert), as `cameraPerspective.ts`. */
+function homographyFromUnitSquare([p0, p1, p2, p3]) {
+	const dx1 = p1[0] - p2[0];
+	const dx2 = p3[0] - p2[0];
+	const dx3 = p0[0] - p1[0] + p2[0] - p3[0];
+	const dy1 = p1[1] - p2[1];
+	const dy2 = p3[1] - p2[1];
+	const dy3 = p0[1] - p1[1] + p2[1] - p3[1];
+	const den = dx1 * dy2 - dx2 * dy1;
+	const g = (dx3 * dy2 - dx2 * dy3) / den;
+	const h = (dx1 * dy3 - dx3 * dy1) / den;
+	return [
+		p1[0] - p0[0] + g * p1[0],
+		p3[0] - p0[0] + h * p3[0],
+		p0[0],
+		p1[1] - p0[1] + g * p1[1],
+		p3[1] - p0[1] + h * p3[1],
+		p0[1],
+		g,
+		h,
+		1,
+	];
+}
+
+function invert3([a, b, c, d, e, f, g, h, i]) {
+	const det = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
+	return [
+		(e * i - f * h) / det,
+		(c * h - b * i) / det,
+		(b * f - c * e) / det,
+		(f * g - d * i) / det,
+		(a * i - c * g) / det,
+		(c * d - a * f) / det,
+		(d * h - e * g) / det,
+		(b * g - a * h) / det,
+		(a * e - b * d) / det,
+	];
+}
+
+function generate(dir) {
+	fs.mkdirSync(dir, { recursive: true });
+	const media = {
+		screen: path.join(dir, "screen.mp4"),
+		cam0: path.join(dir, "cam0.mp4"),
+		cam1: path.join(dir, "cam1.mp4"),
+		cam2: path.join(dir, "cam2.mp4"),
+	};
+	encode(`color=c=0x303030:s=1920x1080:r=30:d=${DURATION_S}`, null, media.screen);
+	encode(`color=c=red:s=${CAM_W}x${CAM_H}:r=30:d=${DURATION_S}`, null, media.cam0);
+	encode(`color=c=0x00ff00:s=${CAM_W}x${CAM_H}:r=30:d=${DURATION_S}`, null, media.cam1);
+	// ffmpeg's `perspective` filter is GPL-only, and the vendored build is LGPL: the board is
+	// drawn straight in perspective instead. Each output pixel centre is mapped back onto the
+	// board's unit square by the inverse homography, so the true corners are exact.
+	const inv = invert3(homographyFromUnitSquare(BOARD_CORNERS_PX));
+	const [s, u, w] = [0, 3, 6].map((r) => `(${inv[r]}*(X+0.5)+${inv[r + 1]}*(Y+0.5)+${inv[r + 2]})`);
+	const board = (cols, rows) =>
+		`geq=lum='st(0,${s}/${w});st(1,${u}/${w});` +
+		`if(lt(ld(0),0)+gte(ld(0),1)+lt(ld(1),0)+gte(ld(1),1),128,` +
+		`if(mod(floor(ld(0)*${cols})+floor(ld(1)*${rows}),2),235,16))':cb=128:cr=128`;
+	const black = `color=c=black:s=${CAM_W}x${CAM_H}:r=30:d=${DURATION_S},format=yuv420p`;
+	encode(black, board(CAM_W / SQUARE_PX, CAM_H / SQUARE_PX), media.cam2);
+	media.board43 = path.join(dir, "board43.mp4");
+	encode(black, board(BOARD43.cols, BOARD43.rows), media.board43);
+
+	const track = (sourcePath, label) => ({
+		sourcePath,
+		startMs: 0,
+		offsetMs: 0,
+		visible: true,
+		width: CAM_W,
+		height: CAM_H,
+		...(label === undefined ? {} : { label }),
+	});
+	const corners = BOARD_CORNERS_PX.map(([x, y]) => ({ x: x / CAM_W, y: y / CAM_H }));
+	const slotted = (regions) =>
+		regions.map(({ cameras, ...region }) => ({
+			...region,
+			slots: cameras.map((camera) => ({ camera })),
+		}));
+	// kind: "multicam" | "onecam" | "persp" | "seam".
+	const project = (kind) => ({
+		schemaVersion: 8,
+		project: {
+			id: `proj_${kind}_fixture`,
+			title: `${kind} fixture`,
+			createdAt: "2026-10-05T00:00:00.000Z",
+			updatedAt: "2026-10-05T00:00:00.000Z",
+			primaryAssetId: "asset_screen",
+		},
+		assets: [
+			{
+				id: "asset_screen",
+				kind: "video",
+				label: "screen.mp4",
+				originalPath: media.screen,
+				durationSec: DURATION_S,
+				sizeBytes: fs.statSync(media.screen).size,
+				video: { codec: "unknown", width: 1920, height: 1080, fps: 30 },
+				cameraTrack: track(kind === "persp" ? media.board43 : media.cam0),
+				...(kind === "multicam"
+					? {
+							additionalCameraTracks: [track(media.cam1, "Green"), track(media.cam2, "Board")],
+						}
+					: {}),
+				...(kind === "seam" ? { additionalCameraTracks: [track(media.cam1, "Green")] } : {}),
+			},
+		],
+		transcript: null,
+		transcripts: [],
+		timeline: {
+			clips: [
+				{
+					id: "clip_main",
+					assetId: "asset_screen",
+					sourceStartSec: 0,
+					sourceEndSec: DURATION_S,
+					timelineStartSec: 0,
+					timelineEndSec: DURATION_S,
+					wordRefs: [],
+					origin: "user",
+					reason: "Fixture",
+				},
+			],
+			gaps: [],
+			trimRanges: [],
+			muteRanges: [],
+			speedRanges: [],
+			captionRanges: [],
+		},
+		annotations: [],
+		zoomRanges: [],
+		audioTracks: [],
+		legacyEditor: {
+			wallpaper: "#101010",
+			wallpaperMotion: "none",
+			frame: "none",
+			shadowIntensity: 0,
+			backgroundBlur: 0,
+			motionBlurAmount: 0,
+			webcamLayoutPreset: "picture-in-picture",
+			webcamMaskShape: "rectangle",
+			webcamRoundness: 0.1,
+			webcamBackgroundMode: "none",
+			...(kind === "multicam"
+				? {
+						cameraLayoutRegions: slotted(REGIONS),
+						cameraSettings: [null, null, { perspective: { corners, aspect: BOARD_ASPECT } }],
+					}
+				: {}),
+			...(kind === "persp"
+				? {
+						cameraLayoutRegions: slotted(PERSP_REGIONS),
+						cameraSettings: [{ perspective: { corners, aspect: BOARD43.aspect } }],
+					}
+				: {}),
+			...(kind === "seam" ? { cameraLayoutRegions: slotted(SEAM_REGIONS) } : {}),
+		},
+	});
+	for (const kind of ["multicam", "onecam", "persp", "seam"]) {
+		const file = path.join(dir, `${kind}.openscreen`);
+		fs.writeFileSync(file, `${JSON.stringify(project(kind), null, 2)}\n`);
+		console.log(`wrote ${file}`);
+	}
+}
+
+/**
+ * Runs the headless export and prints its wall-clock time, and the render time alone: from
+ * the first progress line to "Exported", which leaves Electron's start-up and the project
+ * load out.
+ */
+function exportProject(projectPath, outPath) {
+	const electron = createRequire(import.meta.url)("electron");
+	const started = performance.now();
+	let firstProgress = null;
+	let exported = null;
+	const child = spawn(electron, [ROOT, "export", projectPath, "-o", outPath], {
+		cwd: ROOT,
+		stdio: ["ignore", "pipe", "pipe"],
+	});
+	const watch = (chunk, sink) => {
+		const text = chunk.toString();
+		if (firstProgress === null && text.includes("Exporting")) firstProgress = performance.now();
+		if (exported === null && text.includes("Exported")) exported = performance.now();
+		sink.write(text);
+	};
+	child.stdout.on("data", (chunk) => watch(chunk, process.stdout));
+	child.stderr.on("data", (chunk) => watch(chunk, process.stderr));
+	child.once("exit", (code) => {
+		const seconds = (performance.now() - started) / 1000;
+		const render =
+			firstProgress !== null && exported !== null
+				? `${((exported - firstProgress) / 1000).toFixed(2)} s`
+				: "unknown";
+		console.log(`export exit=${code} wall=${seconds.toFixed(2)} s render=${render}`);
+		process.exitCode = code ?? 1;
+	});
+}
+
+// --- checking ---------------------------------------------------------------------------
+
+/** Minimal P6 reader: {width, height, data} with 3 bytes per pixel. */
+function readPpm(file) {
+	const buf = fs.readFileSync(file);
+	const fields = [];
+	let i = 0;
+	while (fields.length < 4) {
+		while (/\s/.test(String.fromCharCode(buf[i]))) i++;
+		if (buf[i] === 0x23) {
+			while (buf[i] !== 0x0a) i++;
+			continue;
+		}
+		let token = "";
+		while (!/\s/.test(String.fromCharCode(buf[i]))) token += String.fromCharCode(buf[i++]);
+		fields.push(token);
+	}
+	if (fields[0] !== "P6" || fields[3] !== "255") throw new Error(`${file}: not an 8-bit P6`);
+	return { width: Number(fields[1]), height: Number(fields[2]), data: buf.subarray(i + 1) };
+}
+
+/** One ffmpeg pass that writes the given frame indices as PPMs, in order. */
+function extractFrames(video, indices, dir) {
+	fs.rmSync(dir, { recursive: true, force: true });
+	fs.mkdirSync(dir, { recursive: true });
+	const select = indices.map((n) => `eq(n\\,${n})`).join("+");
+	run(FFMPEG, [
+		"-hide_banner",
+		"-loglevel",
+		"error",
+		"-i",
+		video,
+		"-vf",
+		`select='${select}'`,
+		"-fps_mode",
+		"passthrough",
+		"-c:v",
+		"ppm",
+		path.join(dir, "f%04d.ppm"),
+	]);
+	return new Map(
+		indices.map((n, k) => [n, readPpm(path.join(dir, `f${String(k + 1).padStart(4, "0")}.ppm`))]),
+	);
+}
+
+const isRed = (r, g, b) => r > 150 && g < 100 && b < 100;
+const isGreen = (r, g, b) => g > 150 && r < 100 && b < 100;
+
+/** Bounding box [x0, y0, x1, y1) of the pixels `test` accepts, and how many there are. */
+function bbox(frame, test) {
+	let x0 = Infinity;
+	let y0 = Infinity;
+	let x1 = -1;
+	let y1 = -1;
+	let count = 0;
+	const { width, height, data } = frame;
+	for (let y = 0; y < height; y++) {
+		for (let x = 0; x < width; x++) {
+			const o = (y * width + x) * 3;
+			if (!test(data[o], data[o + 1], data[o + 2])) continue;
+			count++;
+			if (x < x0) x0 = x;
+			if (x > x1) x1 = x;
+			if (y < y0) y0 = y;
+			if (y > y1) y1 = y;
+		}
+	}
+	return count === 0 ? null : { box: [x0, y0, x1 + 1, y1 + 1], count };
+}
+
+/**
+ * A template PiP of a 16:9 camera, like `pipLayer`: anchored on camera 1's default PiP
+ * (`anchor`, [x, y, w, h] fractions: its width, right and bottom edges), stacking leftwards;
+ * the corner constants without one.
+ */
+function pipRect(index, frame, anchor) {
+	const w = anchor ? anchor[2] : PIP_WIDTH_FRAC;
+	const h = (w * frame.width) / (16 / 9) / frame.height;
+	const firstRight = anchor ? anchor[0] + anchor[2] : 1 - PIP_MARGIN_FRAC;
+	const right = firstRight - index * (w + PIP_GAP_FRAC);
+	const bottom = anchor
+		? anchor[1] + anchor[3]
+		: 1 - (PIP_MARGIN_FRAC * frame.width) / frame.height;
+	return [right - w, bottom - h, w, h];
+}
+
+/** Each region's layers as {camera: [x, y, w, h]} (fractions), like `resolveCameraLayout`. */
+function regionLayers(region, frame, anchor) {
+	const out = {};
+	region.cameras.forEach((camera, i) => {
+		if (region.template === "camera-full" || (region.template === "camera-full-pip" && i === 0)) {
+			out[camera] = [0, 0, 1, 1];
+		} else if (region.template === "side-by-side") {
+			out[camera] = i === 0 ? [0, 0, 0.5, 1] : [0.5, 0, 0.5, 1];
+		} else {
+			out[camera] = pipRect(region.template === "camera-full-pip" ? i - 1 : i, frame, anchor);
+		}
+	});
+	return out;
+}
+
+function cubicBezier(x1, y1, x2, y2, x) {
+	const sample = (a, b, t) => ((1 - 3 * b + 3 * a) * t + (3 * b - 6 * a)) * t * t + 3 * a * t;
+	let lo = 0;
+	let hi = 1;
+	for (let i = 0; i < 60; i++) {
+		const mid = (lo + hi) / 2;
+		if (sample(x1, x2, mid) < x) lo = mid;
+		else hi = mid;
+	}
+	return sample(y1, y2, (lo + hi) / 2);
+}
+const ease = (t) => cubicBezier(0.16, 1, 0.3, 1, Math.min(1, Math.max(0, t)));
+
+/**
+ * The rect each camera is planned at, at source time t: `camera_layers_at` in
+ * crates/compositor/src/camera_layers.rs for these regions (no speed regions, so the screen
+ * clock is the source clock). `fallback` is camera 0's default rect outside every region.
+ * Opacity is ignored: the check only looks at where a camera is.
+ */
+function plannedRects(t, frame, fallback, regions = REGIONS) {
+	const sec = (ms) => ms / 1000;
+	// A camera-1 camera-full region is a Full Camera section, not a layout region; it is a
+	// layout region's neighbour only at a seam, with camera 1 on the whole frame.
+	const isFullCamera = (r) => r.template === "camera-full" && r.cameras[0] === 0;
+	const layouts = regions.filter((r) => !isFullCamera(r));
+	const index = layouts.findIndex((r) => sec(r.startMs) <= t && t <= sec(r.endMs));
+	const fallbackLayers = { 0: fallback };
+	if (index < 0) return fallbackLayers;
+	const region = layouts[index];
+	const [start, end] = [sec(region.startMs), sec(region.endMs)];
+	const prev = regions.find((r) => r !== region && Math.abs(sec(r.endMs) - start) <= 0.001);
+	const hasNext = regions.some((r) => r !== region && Math.abs(sec(r.startMs) - end) <= 0.001);
+	const current = regionLayers(region, frame, fallback);
+	const half = (end - start) / 2;
+	const winIn = Math.min(TRANSITION_WINDOW_S, half);
+	const winOut = Math.min(FULLSCREEN_LEAD_OUT_WINDOW_S, half);
+	const blend = (from, to, k) => {
+		const out = {};
+		for (const [camera, rect] of Object.entries(to)) {
+			const a = from[camera];
+			out[camera] = a ? rect.map((v, i) => a[i] + (v - a[i]) * k) : rect;
+		}
+		for (const [camera, rect] of Object.entries(from)) out[camera] ??= rect;
+		return out;
+	};
+	if (t - start < winIn) {
+		return blend(
+			prev ? regionLayers(prev, frame, fallback) : fallbackLayers,
+			current,
+			ease((t - start) / winIn),
+		);
+	}
+	if (!hasNext && end - t < winOut) {
+		return blend(current, fallbackLayers, 1 - ease((end - t) / winOut));
+	}
+	return current;
+}
+
+const toPx = ([x, y, w, h], frame) => [
+	x * frame.width,
+	y * frame.height,
+	(x + w) * frame.width,
+	(y + h) * frame.height,
+];
+/** Largest edge distance (px) between a measured box and a planned rect. */
+function boxError(measured, rect, frame) {
+	if (!measured) return Infinity;
+	const want = toPx(rect, frame);
+	return Math.max(...measured.box.map((v, i) => Math.abs(v - want[i])));
+}
+const fmtBox = (m) => (m ? `[${m.box.join(", ")}]` : "none");
+const fmtRect = (rect, frame) =>
+	`[${toPx(rect, frame)
+		.map((v) => v.toFixed(1))
+		.join(", ")}]`;
+
+/** Sub-pixel positions where the luminance along a line crosses mid-grey. */
+function edgesAlong(frame, horizontal, at) {
+	const { width, height, data } = frame;
+	const n = horizontal ? width : height;
+	const lum = (i) => {
+		const o = horizontal ? (at * width + i) * 3 : (i * width + at) * 3;
+		return (data[o] + data[o + 1] + data[o + 2]) / 3;
+	};
+	const edges = [];
+	for (let i = 1; i < n; i++) {
+		const a = lum(i - 1) - 128;
+		const b = lum(i) - 128;
+		if (a < 0 !== b < 0) edges.push(i - 1 + a / (a - b) + 0.5);
+	}
+	return edges;
+}
+
+/**
+ * The rectified board, cover-fitted into the frame like any other camera: squares of one size
+ * `s = max(W / cols, H / rows)`, centred, so its edges sit at `centre + k * s` on both axes.
+ * Checks three rows and three columns: edges where the square grid puts them (right angles and
+ * equal square sizes), and equally spaced within each line.
+ */
+function boardCheck(frame, cols = CAM_W / SQUARE_PX, rows = CAM_H / SQUARE_PX) {
+	const { width, height } = frame;
+	const size = Math.max(width / cols, height / rows);
+	const along = (centre, count, extent) => {
+		const out = [];
+		for (let k = -count; k <= count; k++) {
+			const e = centre + (k - count / 2) * size;
+			if (e > 3 && e < extent - 3) out.push(e);
+		}
+		return out;
+	};
+	const lines = [
+		...[1, 4, 7].map((r) => ({
+			horizontal: true,
+			at: Math.round(height / 2 + (r - rows / 2 + 0.5) * size),
+			want: along(width / 2, cols, width),
+		})),
+		...[2, Math.floor(cols / 2), cols - 3].map((c) => ({
+			horizontal: false,
+			at: Math.round(width / 2 + (c - cols / 2 + 0.5) * size),
+			want: along(height / 2, rows, height),
+		})),
+	];
+	let spacingError = 0;
+	let gridError = 0;
+	const found = [];
+	const steps = { horizontal: [], vertical: [] };
+	for (const line of lines) {
+		const edges = edgesAlong(frame, line.horizontal, line.at);
+		found.push(`${edges.length}/${line.want.length}`);
+		if (edges.length < 2) {
+			spacingError = Infinity;
+			gridError = Infinity;
+			continue;
+		}
+		const step = (edges[edges.length - 1] - edges[0]) / (edges.length - 1);
+		steps[line.horizontal ? "horizontal" : "vertical"].push(step);
+		edges.forEach((e, k) => {
+			spacingError = Math.max(spacingError, Math.abs(e - (edges[0] + k * step)));
+		});
+		if (edges.length !== line.want.length) {
+			gridError = Infinity;
+			continue;
+		}
+		edges.forEach((e, k) => {
+			gridError = Math.max(gridError, Math.abs(e - line.want[k]));
+		});
+	}
+	const mean = (v) => v.reduce((x, y) => x + y, 0) / v.length;
+	return {
+		lines: lines.length,
+		found,
+		size,
+		spacingError,
+		gridError,
+		stepH: mean(steps.horizontal),
+		stepV: mean(steps.vertical),
+	};
+}
+
+function report(rows) {
+	for (const r of rows) {
+		const verdict = r.pass === null ? "INFO" : r.pass ? "PASS" : "FAIL";
+		console.log(`${verdict} | ${r.name} | ${r.measured} | expected ${r.expected}`);
+	}
+	const checked = rows.filter((r) => r.pass !== null);
+	const failed = checked.filter((r) => !r.pass).length;
+	console.log(`${checked.length - failed}/${checked.length} passed`);
+	process.exitCode = failed === 0 ? 0 : 1;
+}
+
+const fractionsOf = (found, frame) =>
+	found
+		? [
+				found.box[0] / frame.width,
+				found.box[1] / frame.height,
+				(found.box[2] - found.box[0]) / frame.width,
+				(found.box[3] - found.box[1]) / frame.height,
+			]
+		: null;
+
+const isWhite = (r, g, b) => r > 200 && g > 200 && b > 200;
+
+/**
+ * The board inside a box (`box` = [x0, y0, x1, y1) px): the mean square step across (from
+ * three rows) and down (from three columns), from the luminance edges strictly inside it.
+ */
+function boardInBox(frame, box, cols, rows) {
+	const [x0, y0, x1, y1] = box;
+	const { width, data } = frame;
+	const lum = (x, y) => {
+		const o = (y * width + x) * 3;
+		return (data[o] + data[o + 1] + data[o + 2]) / 3 - 128;
+	};
+	const edges = (horizontal, at) => {
+		const out = [];
+		const [lo, hi] = horizontal ? [x0 + 3, x1 - 3] : [y0 + 3, y1 - 3];
+		for (let i = lo + 1; i < hi; i++) {
+			const a = horizontal ? lum(i - 1, at) : lum(at, i - 1);
+			const b = horizontal ? lum(i, at) : lum(at, i);
+			if (a < 0 !== b < 0) out.push(i - 1 + a / (a - b) + 0.5);
+		}
+		return out;
+	};
+	const step = (e) => (e.length < 2 ? Number.NaN : (e[e.length - 1] - e[0]) / (e.length - 1));
+	const [bw, bh] = [x1 - x0, y1 - y0];
+	const across = [1, Math.floor(rows / 2), rows - 2].map((r) =>
+		step(edges(true, Math.round(y0 + ((r + 0.5) * bh) / rows))),
+	);
+	const down = [2, Math.floor(cols / 2), cols - 3].map((c) =>
+		step(edges(false, Math.round(x0 + ((c + 0.5) * bw) / cols))),
+	);
+	const mean = (v) => v.reduce((x, y) => x + y, 0) / v.length;
+	return { stepH: mean(across), stepV: mean(down) };
+}
+
+function checkPersp(video) {
+	const frameAt = (sec) => Math.round(sec * EXPORT_FPS);
+	const frames = extractFrames(
+		video,
+		[frameAt(1), frameAt(4.25)],
+		path.join(os.tmpdir(), "openscreen-multicam-frames"),
+	);
+	const rows = [];
+	const add = (name, pass, measured, expected) => rows.push({ name, pass, measured, expected });
+	const { cols, rows: boardRows, aspect } = BOARD43;
+
+	// Default PiP: the box takes the perspective's 4:3, and its squares are square.
+	const pipFrame = frames.get(frameAt(1));
+	const pip = bbox(pipFrame, isWhite);
+	const pipAspect = pip ? (pip.box[2] - pip.box[0]) / (pip.box[3] - pip.box[1]) : Number.NaN;
+	const pipHeight = pip ? pip.box[3] - pip.box[1] : 0;
+	add(
+		"1.0 s camera 1 PiP box has the perspective's 4:3",
+		Math.abs(pipAspect * pipHeight - aspect * pipHeight) <= TOLERANCE_PX,
+		`${fmtBox(pip)} ratio ${pipAspect.toFixed(4)}`,
+		`${aspect.toFixed(4)} within ${TOLERANCE_PX} px of width`,
+	);
+	const inPip = pip ? boardInBox(pipFrame, pip.box, cols, boardRows) : { stepH: NaN, stepV: NaN };
+	add(
+		"1.0 s PiP checkerboard squares square (step across vs down)",
+		Math.abs(inPip.stepH - inPip.stepV) <= TOLERANCE_PX,
+		`${inPip.stepH.toFixed(2)} x ${inPip.stepV.toFixed(2)} px`,
+		`equal within ${TOLERANCE_PX} px`,
+	);
+
+	// Full Camera: the 4:3 picture cover-fitted into the frame, squares square and on the grid.
+	const board = boardCheck(frames.get(frameAt(4.25)), cols, boardRows);
+	add(
+		"4.25 s Full Camera checkerboard edges equally spaced",
+		board.spacingError <= TOLERANCE_PX,
+		`${board.lines} lines, edges ${board.found.join(" ")}, max err ${board.spacingError.toFixed(2)} px`,
+		`<= ${TOLERANCE_PX} px`,
+	);
+	add(
+		"4.25 s Full Camera checkerboard squares square (step across vs down)",
+		Math.abs(board.stepH - board.stepV) <= TOLERANCE_PX,
+		`${board.stepH.toFixed(2)} x ${board.stepV.toFixed(2)} px`,
+		`equal within ${TOLERANCE_PX} px`,
+	);
+	add(
+		"4.25 s Full Camera checkerboard on the cover-fitted square grid",
+		board.gridError <= TOLERANCE_PX,
+		`max err ${board.gridError.toFixed(2)} px`,
+		`squares of ${board.size.toFixed(1)} px, centred`,
+	);
+	report(rows);
+}
+
+function checkSeam(video) {
+	const t = (n) => n / EXPORT_FPS;
+	const frameAt = (sec) => Math.round(sec * EXPORT_FPS);
+	const sweep = [];
+	// From after the Full Camera section's own lead-in (1.0 s + 1.015 s) across the seam.
+	for (let n = frameAt(2.05); n <= frameAt(4.2); n += EXPORT_FPS / 30) sweep.push(n);
+	const indices = [...new Set([frameAt(0.5), frameAt(4.6), ...sweep])].sort((a, b) => a - b);
+	const frames = extractFrames(
+		video,
+		indices,
+		path.join(os.tmpdir(), "openscreen-multicam-frames"),
+	);
+	const rows = [];
+	const add = (name, pass, measured, expected) => rows.push({ name, pass, measured, expected });
+	const f05 = frames.get(frameAt(0.5));
+	const fallback = fractionsOf(bbox(f05, isRed), f05);
+	add("0.5 s camera 1 default PiP present", !!fallback, fmtBox(bbox(f05, isRed)), "red box");
+
+	// Up to the seam camera 1 fills the frame: no lead-out of the Full Camera section.
+	let notFull = 0;
+	let worstFull = 0;
+	// From the seam on, camera 1 is on the planned glide from the frame to its PiP slot, and
+	// its box only ever shrinks: it never passes through the default PiP and back. (The slot
+	// IS the default PiP's rect — template PiPs anchor on it — so where it ends proves
+	// nothing; where the glide starts does.)
+	let worstGlide = 0;
+	let grows = 0;
+	let lastArea = Infinity;
+	let firstAfterSeam = null;
+	const trace = [];
+	for (const n of sweep) {
+		const frame = frames.get(n);
+		const got = bbox(frame, isRed);
+		const area = got ? (got.box[2] - got.box[0]) * (got.box[3] - got.box[1]) : 0;
+		trace.push(`${t(n).toFixed(2)}:${got ? got.box[0] : "-"}`);
+		if (t(n) < 3) {
+			const err = boxError(got, [0, 0, 1, 1], frame);
+			worstFull = Math.max(worstFull, err);
+			if (err > TOLERANCE_PX) notFull++;
+		} else {
+			const want = plannedRects(t(n), frame, fallback, SEAM_REGIONS)[0];
+			worstGlide = Math.max(worstGlide, boxError(got, want, frame));
+			if (area > lastArea + 4 * frame.width) grows++;
+			if (t(n) > 3 && firstAfterSeam === null) firstAfterSeam = { n, got, width: frame.width };
+		}
+		lastArea = t(n) >= 3 ? area : lastArea;
+	}
+	add(
+		"2.05-3.0 s camera 1 fills the frame up to the seam",
+		notFull === 0,
+		`${notFull} frames off, max err ${worstFull.toFixed(2)} px`,
+		`0 (<= ${TOLERANCE_PX} px)`,
+	);
+	add(
+		"3.0-4.2 s camera 1 on the planned glide from the frame",
+		worstGlide <= TOLERANCE_PX,
+		`max err ${worstGlide.toFixed(2)} px; left edge ${trace.filter((_, k) => k % 6 === 0).join(" ")}`,
+		`<= ${TOLERANCE_PX} px`,
+	);
+	add("3.0-4.2 s camera 1 box never grows back", grows === 0, `${grows} growing steps`, "0");
+	{
+		// The first frame after the seam is barely into the glide: still nearly the whole frame.
+		// Gliding from the default PiP instead, it would already be PiP-sized.
+		const first = firstAfterSeam;
+		const w = first?.got ? first.got.box[2] - first.got.box[0] : 0;
+		add(
+			`${first ? t(first.n).toFixed(3) : "?"} s glide starts from the frame, not the default PiP`,
+			!!first && w >= 0.75 * first.width,
+			first ? `${fmtBox(first.got)} width ${w} px` : "no frame",
+			`>= ${first ? (0.75 * first.width).toFixed(0) : "?"} px wide`,
+		);
+	}
+	const f46 = frames.get(frameAt(4.6));
+	const slot = plannedRects(t(frameAt(4.6)), f46, fallback, SEAM_REGIONS);
+	const red = bbox(f46, isRed);
+	const redErr = boxError(red, slot[0], f46);
+	add(
+		"4.6 s camera 1 in its PiP slot",
+		redErr <= TOLERANCE_PX,
+		`${fmtBox(red)} err ${redErr.toFixed(2)} px`,
+		fmtRect(slot[0], f46),
+	);
+	const green = bbox(f46, isGreen);
+	add(
+		"4.6 s camera 2 fills the frame under it",
+		boxError(green, [0, 0, 1, 1], f46) <= TOLERANCE_PX,
+		fmtBox(green),
+		fmtRect([0, 0, 1, 1], f46),
+	);
+	report(rows);
+}
+
+function check(video) {
+	const t = (n) => n / EXPORT_FPS;
+	const frameAt = (sec) => Math.round(sec * EXPORT_FPS);
+	const glide = [];
+	for (let n = frameAt(2.9); n <= frameAt(3.6); n += EXPORT_FPS / 30) glide.push(n);
+	const indices = [
+		...new Set([
+			frameAt(0.5),
+			frameAt(2),
+			frameAt(4),
+			frameAt(6),
+			frameAt(6.5),
+			frameAt(7.5),
+			...glide,
+		]),
+	].sort((a, b) => a - b);
+	const frames = extractFrames(
+		video,
+		indices,
+		path.join(os.tmpdir(), "openscreen-multicam-frames"),
+	);
+	const rows = [];
+	const add = (name, pass, measured, expected) => rows.push({ name, pass, measured, expected });
+
+	const f05 = frames.get(frameAt(0.5));
+	const fallbackBox = bbox(f05, isRed);
+	const fallback = fallbackBox
+		? [
+				fallbackBox.box[0] / f05.width,
+				fallbackBox.box[1] / f05.height,
+				(fallbackBox.box[2] - fallbackBox.box[0]) / f05.width,
+				(fallbackBox.box[3] - fallbackBox.box[1]) / f05.height,
+			]
+		: null;
+	add(
+		"0.5 s camera 1 default PiP present (reference for 6.0 s)",
+		!!fallbackBox,
+		fmtBox(fallbackBox),
+		"red box",
+	);
+	add("0.5 s no other camera", !bbox(f05, isGreen), fmtBox(bbox(f05, isGreen)), "no green");
+
+	const atRect = (sec, camera, test, label) => {
+		const frame = frames.get(frameAt(sec));
+		const want = plannedRects(t(frameAt(sec)), frame, fallback)[camera];
+		const got = bbox(frame, test);
+		const err = boxError(got, want, frame);
+		add(
+			`${sec.toFixed(1)} s ${label}`,
+			err <= TOLERANCE_PX,
+			`${fmtBox(got)} err ${err.toFixed(2)} px`,
+			fmtRect(want, frame),
+		);
+	};
+	atRect(2, 0, isRed, "red PiP (screen-pip slot 0)");
+	atRect(2, 1, isGreen, "green PiP (screen-pip slot 1)");
+	atRect(4, 1, isGreen, "green fills the frame (camera-full-pip)");
+	atRect(4, 0, isRed, "red PiP over it");
+
+	// The glide across 3.0 s: green present in every frame, on the planned rect, and growing.
+	let worst = 0;
+	let missing = 0;
+	let shrinks = 0;
+	let lastArea = 0;
+	const trace = [];
+	for (const n of glide) {
+		const frame = frames.get(n);
+		const got = bbox(frame, isGreen);
+		if (!got || got.count < 1000) missing++;
+		const want = plannedRects(t(n), frame, fallback)[1];
+		worst = Math.max(worst, boxError(got, want, frame));
+		const area = got ? (got.box[2] - got.box[0]) * (got.box[3] - got.box[1]) : 0;
+		if (area + 4 * frame.width < lastArea) shrinks++;
+		lastArea = area;
+		trace.push(`${t(n).toFixed(3)}:${got ? got.box[0] : "-"}`);
+	}
+	add(
+		`2.9-3.6 s green present in all ${glide.length} frames`,
+		missing === 0,
+		`${missing} without green`,
+		"0",
+	);
+	add(
+		"2.9-3.6 s green on the planned glide rect",
+		worst <= TOLERANCE_PX,
+		`max err ${worst.toFixed(2)} px`,
+		`<= ${TOLERANCE_PX} px`,
+	);
+	add("2.9-3.6 s green box never shrinks", shrinks === 0, `${shrinks} shrinking steps`, "0");
+	const firstMoving = glide.find((n) => t(n) > 3);
+	const lastGlide = glide[glide.length - 1];
+	const k0 = plannedRects(t(firstMoving), frames.get(firstMoving), fallback)[1];
+	add(
+		"2.9-3.6 s glide starts at the 3.0 s boundary",
+		boxError(
+			bbox(frames.get(frameAt(2.9)), isGreen),
+			pipRect(1, frames.get(frameAt(2.9)), fallback),
+			frames.get(frameAt(2.9)),
+		) <= TOLERANCE_PX && k0[0] < pipRect(1, frames.get(firstMoving), fallback)[0],
+		`left edge ${trace.slice(0, 6).join(" ")} ... ${trace[trace.length - 1]}`,
+		`PiP until 3.0, then x -> 0 (by ${t(lastGlide).toFixed(2)} s planned x ${(plannedRects(t(lastGlide), frames.get(lastGlide), fallback)[1][0] * frames.get(lastGlide).width).toFixed(1)})`,
+	);
+
+	{
+		// Green (slot 1) is drawn after red, so it hides whatever of red's still-gliding rect
+		// overhangs the right half: red's visible right edge is green's left edge.
+		const frame = frames.get(frameAt(6));
+		const planned = plannedRects(t(frameAt(6)), frame, fallback);
+		const [x, y, w, h] = planned[0];
+		const visible = [x, y, Math.min(x + w, planned[1][0]) - x, h];
+		const got = bbox(frame, isRed);
+		const err = boxError(got, visible, frame);
+		add(
+			"6.0 s red, left half (lead-in from the default, k = ease(2/3)), under green",
+			err <= TOLERANCE_PX,
+			`${fmtBox(got)} err ${err.toFixed(2)} px`,
+			fmtRect(visible, frame),
+		);
+		const settled = boxError(got, [0, 0, 0.5, 1], frame);
+		add("6.0 s red vs the settled left half", null, `err ${settled.toFixed(2)} px`, "information");
+	}
+	atRect(6, 1, isGreen, "green, right half (fading in)");
+	atRect(6.5, 0, isRed, "red, settled left half");
+	atRect(6.5, 1, isGreen, "green, settled right half");
+
+	const board = boardCheck(frames.get(frameAt(7.5)));
+	add(
+		"7.5 s checkerboard edges equally spaced",
+		board.spacingError <= TOLERANCE_PX,
+		`${board.lines} lines, edges ${board.found.join(" ")}, max err ${board.spacingError.toFixed(2)} px`,
+		`<= ${TOLERANCE_PX} px`,
+	);
+	add(
+		"7.5 s checkerboard squares square (step across vs down)",
+		Math.abs(board.stepH - board.stepV) <= TOLERANCE_PX,
+		`${board.stepH.toFixed(2)} x ${board.stepV.toFixed(2)} px`,
+		`equal within ${TOLERANCE_PX} px`,
+	);
+	add(
+		"7.5 s checkerboard on the cover-fitted square grid",
+		board.gridError <= TOLERANCE_PX,
+		`max err ${board.gridError.toFixed(2)} px`,
+		`squares of ${board.size.toFixed(1)} px, centred`,
+	);
+
+	report(rows);
+}
+
+const [command, a, b] = process.argv.slice(2);
+if (command === "generate" && a) generate(path.resolve(a));
+else if (command === "export" && a && b) exportProject(path.resolve(a), path.resolve(b));
+else if (command === "check" && a && (b ?? "multicam") === "multicam") check(path.resolve(a));
+else if (command === "check" && a && b === "persp") checkPersp(path.resolve(a));
+else if (command === "check" && a && b === "seam") checkSeam(path.resolve(a));
+else {
+	console.error(
+		"usage: multicam-fixture.mjs generate <dir> | export <project> <out.mp4> | check <out.mp4> [multicam|persp|seam]",
+	);
+	process.exitCode = 2;
+}
diff --git a/src/cli/CliExportRunner.clipList.test.ts b/src/cli/CliExportRunner.clipList.test.ts
new file mode 100644
index 000000000..39696c400
--- /dev/null
+++ b/src/cli/CliExportRunner.clipList.test.ts
@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { type AxcutAsset, type AxcutDocument, axcutSchemaVersion } from "@/lib/ai-edition/schema";
+import { buildNativeClipList } from "./CliExportRunner";
+
+function doc(asset: AxcutAsset): AxcutDocument {
+	return {
+		schemaVersion: axcutSchemaVersion,
+		project: {
+			id: "proj_1",
+			title: "Cli",
+			createdAt: "2026-10-05T10:00:00Z",
+			updatedAt: "2026-10-05T10:00:00Z",
+			primaryAssetId: asset.id,
+		},
+		assets: [asset],
+		transcript: null,
+		transcripts: [],
+		timeline: {
+			clips: [
+				{
+					id: "c1",
+					assetId: asset.id,
+					sourceStartSec: 0,
+					sourceEndSec: 10,
+					timelineStartSec: 0,
+					timelineEndSec: 10,
+					wordRefs: [],
+					origin: "user",
+					reason: "",
+				},
+			],
+			gaps: [],
+			trimRanges: [],
+			muteRanges: [],
+			speedRanges: [],
+			captionRanges: [],
+		},
+		annotations: [],
+		zoomRanges: [],
+		audioTracks: [],
+		legacyEditor: null,
+	};
+}
+
+const ASSET: AxcutAsset = {
+	id: "a1",
+	kind: "video",
+	label: "asset",
+	originalPath: "/tmp/a.mp4",
+	cameraTrack: null,
+};
+
+describe("CLI export clip list", () => {
+	it("carries the asset's extra cameras", () => {
+		const clips = buildNativeClipList(
+			doc({
+				...ASSET,
+				additionalCameraTracks: [
+					{ sourcePath: "/tmp/cam2.mp4", startMs: 1000, offsetMs: -250, visible: true, label: "" },
+				],
+			}),
+		);
+		expect(clips).toHaveLength(1);
+		expect(clips[0].additionalCameras).toEqual([{ path: "/tmp/cam2.mp4", offsetSec: 0.75 }]);
+	});
+
+	it("sends no extra cameras for a one-camera asset", () => {
+		const clips = buildNativeClipList(doc(ASSET));
+		expect(clips[0]).not.toHaveProperty("additionalCameras");
+	});
+});
diff --git a/src/cli/CliExportRunner.tsx b/src/cli/CliExportRunner.tsx
index de080359e..52f28ff45 100644
--- a/src/cli/CliExportRunner.tsx
+++ b/src/cli/CliExportRunner.tsx
@@ -26,7 +26,7 @@ import {
 	appendAutoZoomSuggestions,
 	collectAutoZoomSuggestionsForDocument,
 } from "@/lib/ai-edition/timeline/apply-auto-zooms";
-import { assetCameraSource } from "@/lib/ai-edition/timeline/camera";
+import { assetAdditionalCameraSources, assetCameraSource } from "@/lib/ai-edition/timeline/camera";
 import { resolveClipSourceEndSec } from "@/lib/ai-edition/timeline/clipDuration";
 import type { CliDoneResult, CliExportRequest } from "@/lib/cliContracts";
 import { GIF_SIZE_PRESETS, type GifSizePreset } from "@/lib/exporter";
@@ -79,7 +79,7 @@ function replaceExtension(filePath: string, newExtension: string): string {
 /** Mirrors ExportDialog.buildNativeClipList: trim-narrowed visible clips mapped
  * onto the native multiclip contract. Kept in lock-step with
  * buildSceneDescription so export and scene agree on the clip stream. */
-function buildNativeClipList(axcutDocument: AxcutDocument): CompositorClipInput[] {
+export function buildNativeClipList(axcutDocument: AxcutDocument): CompositorClipInput[] {
 	const assetById = new Map(axcutDocument.assets.map((asset) => [asset.id, asset]));
 	return resolveVisibleClips(axcutDocument).flatMap((clip) => {
 		const asset = assetById.get(clip.assetId);
@@ -87,6 +87,8 @@ function buildNativeClipList(axcutDocument: AxcutDocument): CompositorClipInput[
 			return [];
 		}
 		const camera = assetCameraSource(asset);
+		// Cameras 2-4, only sent when the asset has any (same rule as `buildSceneDescription`).
+		const additionalCameras = assetAdditionalCameraSources(asset);
 		const sourceEndSec = resolveClipSourceEndSec(clip, asset);
 		return [
 			{
@@ -96,6 +98,7 @@ function buildNativeClipList(axcutDocument: AxcutDocument): CompositorClipInput[
 				sourceEndSec,
 				webcamOffsetSec: camera.offsetSec,
 				hasAudio: true,
+				...(additionalCameras.length > 0 ? { additionalCameras } : {}),
 			},
 		];
 	});
diff --git a/src/components/ai-edition/CameraCalibrationModal.test.tsx b/src/components/ai-edition/CameraCalibrationModal.test.tsx
new file mode 100644
index 000000000..0e68013dc
--- /dev/null
+++ b/src/components/ai-edition/CameraCalibrationModal.test.tsx
@@ -0,0 +1,330 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { CameraSettings } from "@/components/video-editor/types";
+
+vi.mock("@/contexts/I18nContext", () => ({
+	useScopedT: (scope: string) => (key: string) => `${scope}.${key}`,
+}));
+
+// A small still: 50 x 40 RGBA. jsdom has neither `ImageData` nor a video decoder.
+const IMAGE = { width: 50, height: 40, data: new Uint8ClampedArray(50 * 40 * 4) } as ImageData;
+vi.mock("@/lib/ai-edition/timeline/grabFrame", () => ({
+	grabFrame: vi.fn(async () => IMAGE),
+}));
+
+const detectCornerMarkers = vi.fn();
+vi.mock("@/lib/arucoMarkers", () => ({
+	detectCornerMarkers: (...args: unknown[]) => detectCornerMarkers(...args),
+}));
+const printMarkerSheet = vi.fn();
+vi.mock("@/lib/markerSheet", () => ({
+	printMarkerSheet: (...args: unknown[]) => printMarkerSheet(...args),
+}));
+
+import { CameraCalibrationModal } from "./CameraCalibrationModal";
+
+const CAMERA = { index: 1, label: "Desk", src: "file:///cam.mp4", timeSec: 2 };
+
+function renderModal(
+	mode: "perspective" | "crop",
+	initial: CameraSettings | null,
+	onApply = vi.fn(),
+	onClose = vi.fn(),
+) {
+	render(
+		<CameraCalibrationModal
+			open
+			camera={CAMERA}
+			mode={mode}
+			initial={initial}
+			onApply={onApply}
+			onClose={onClose}
+		/>,
+	);
+	return { onApply, onClose };
+}
+
+const apply = () => screen.getByRole("button", { name: "dialogs.cameraCalibration.apply" });
+const stillLoaded = () =>
+	waitFor(() => expect(screen.queryByText("dialogs.cameraCalibration.loading")).toBeNull());
+
+describe("CameraCalibrationModal", () => {
+	beforeEach(() => {
+		// jsdom has no 2D canvas: `getContext` would log "not implemented" and return null. The
+		// dialog draws nothing without a context, which is what these tests assume.
+		vi.spyOn(HTMLCanvasElement.prototype, "getContext").mockReturnValue(null);
+	});
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("apply is disabled for a crossed quad", async () => {
+		renderModal("perspective", {
+			perspective: {
+				corners: [
+					{ x: 0.1, y: 0.1 },
+					{ x: 0.9, y: 0.9 },
+					{ x: 0.9, y: 0.1 },
+					{ x: 0.1, y: 0.9 },
+				],
+				aspect: 1,
+			},
+		});
+		await stillLoaded();
+		expect(apply()).toBeDisabled();
+		expect(screen.getByRole("alert")).toHaveTextContent("dialogs.cameraCalibration.invalidQuad");
+	});
+
+	it("apply stores corners, aspect and margin in one call", async () => {
+		const { onApply, onClose } = renderModal("perspective", null);
+		await stillLoaded();
+		fireEvent.click(screen.getByRole("button", { name: "1:1" }));
+		fireEvent.change(screen.getByRole("slider"), { target: { value: "10" } });
+		fireEvent.click(apply());
+		expect(onApply).toHaveBeenCalledTimes(1);
+		expect(onApply).toHaveBeenCalledWith({
+			perspective: {
+				corners: [
+					{ x: 0.15, y: 0.15 },
+					{ x: 0.85, y: 0.15 },
+					{ x: 0.85, y: 0.85 },
+					{ x: 0.15, y: 0.85 },
+				],
+				aspect: 1,
+				margin: 0.1,
+			},
+		});
+		expect(onClose).toHaveBeenCalled();
+	});
+
+	it("arrow keys move the focused handle", async () => {
+		const { onApply } = renderModal("perspective", null);
+		await stillLoaded();
+		const handle = screen.getByTestId("calibration-handle-0");
+		handle.focus();
+		// One image pixel right, then ten down.
+		fireEvent.keyDown(handle, { key: "ArrowRight" });
+		fireEvent.keyDown(handle, { key: "ArrowDown", shiftKey: true });
+		fireEvent.click(apply());
+		const corners = onApply.mock.calls[0][0].perspective.corners;
+		expect(corners[0].x).toBeCloseTo(0.15 + 1 / 50, 9);
+		expect(corners[0].y).toBeCloseTo(0.15 + 10 / 40, 9);
+		expect(corners[1]).toEqual({ x: 0.85, y: 0.15 });
+		// The A4 landscape default.
+		expect(onApply.mock.calls[0][0].perspective.aspect).toBeCloseTo(297 / 210, 9);
+	});
+
+	it("crop mode stores a crop", async () => {
+		const { onApply } = renderModal("crop", null);
+		await stillLoaded();
+		const crop = screen.getByTestId("calibration-crop");
+		// Shrink from the right edge, then move right.
+		for (let i = 0; i < 20; i++) fireEvent.keyDown(crop, { key: "ArrowLeft", shiftKey: true });
+		for (let i = 0; i < 5; i++) fireEvent.keyDown(crop, { key: "ArrowRight" });
+		fireEvent.click(apply());
+		expect(onApply).toHaveBeenCalledTimes(1);
+		const stored = onApply.mock.calls[0][0].crop;
+		expect(stored.x).toBeCloseTo(0.05, 9);
+		expect(stored.y).toBe(0);
+		expect(stored.width).toBeCloseTo(0.8, 9);
+		expect(stored.height).toBe(1);
+	});
+
+	it("cancel stores nothing", async () => {
+		const { onApply, onClose } = renderModal("perspective", null);
+		await stillLoaded();
+		fireEvent.keyDown(screen.getByTestId("calibration-handle-2"), { key: "ArrowLeft" });
+		fireEvent.click(screen.getByRole("button", { name: "common.actions.cancel" }));
+		expect(onClose).toHaveBeenCalled();
+		expect(onApply).not.toHaveBeenCalled();
+	});
+
+	it("an invalid free ratio says why and marks the field", async () => {
+		renderModal("perspective", null);
+		await stillLoaded();
+		fireEvent.click(screen.getByRole("button", { name: "dialogs.cameraCalibration.formats.free" }));
+		const input = screen.getByRole("spinbutton");
+		expect(input).toHaveAttribute("aria-invalid", "false");
+		fireEvent.change(input, { target: { value: "50" } });
+		expect(input).toHaveAttribute("aria-invalid", "true");
+		expect(screen.getByRole("alert")).toHaveTextContent("dialogs.cameraCalibration.invalidRatio");
+		expect(apply()).toBeDisabled();
+	});
+
+	it("a drag ends on pointercancel and its listeners go with the dialog", async () => {
+		const add = vi.spyOn(window, "addEventListener");
+		const remove = vi.spyOn(window, "removeEventListener");
+		const { unmount } = render(
+			<CameraCalibrationModal
+				open
+				camera={CAMERA}
+				mode="crop"
+				initial={null}
+				onApply={vi.fn()}
+				onClose={vi.fn()}
+			/>,
+		);
+		await stillLoaded();
+		const frame = screen.getByTestId("calibration-frame");
+		vi.spyOn(frame, "getBoundingClientRect").mockReturnValue(new DOMRect(0, 0, 100, 80));
+		const crop = screen.getByTestId("calibration-crop");
+		const dragTypes = ["pointermove", "pointerup", "pointercancel"];
+		// The drag's own listeners: added after `from`, still registered unless removed since.
+		const dragListeners = (from: number) =>
+			add.mock.calls.slice(from).filter(([type]) => dragTypes.includes(type));
+		const stillAttached = (from: number) =>
+			dragListeners(from).filter(
+				([type, fn]) => !remove.mock.calls.some(([t, f]) => t === type && f === fn),
+			).length;
+
+		let from = add.mock.calls.length;
+		fireEvent.pointerDown(crop, { clientX: 10, clientY: 10 });
+		expect(dragListeners(from)).toHaveLength(3);
+		fireEvent(window, new Event("pointercancel"));
+		expect(stillAttached(from)).toBe(0);
+
+		// A drag still running when the dialog goes away is ended with it.
+		from = add.mock.calls.length;
+		fireEvent.pointerDown(crop, { clientX: 10, clientY: 10 });
+		expect(stillAttached(from)).toBe(3);
+		unmount();
+		expect(stillAttached(from)).toBe(0);
+	});
+
+	it("detect fills the handles", async () => {
+		const found = [
+			{ x: 0.2, y: 0.25 },
+			{ x: 0.8, y: 0.2 },
+			{ x: 0.85, y: 0.9 },
+			{ x: 0.1, y: 0.8 },
+		];
+		detectCornerMarkers.mockReturnValueOnce(found);
+		const { onApply } = renderModal("perspective", null);
+		await stillLoaded();
+		fireEvent.click(
+			screen.getByRole("button", { name: "dialogs.cameraCalibration.detectMarkers" }),
+		);
+		expect(detectCornerMarkers).toHaveBeenCalledWith(IMAGE);
+		expect(screen.getByRole("status")).toHaveTextContent("dialogs.cameraCalibration.markersFound");
+		fireEvent.click(apply());
+		expect(onApply.mock.calls[0][0].perspective.corners).toEqual(found);
+	});
+
+	it("detect without four markers shows the message and keeps the handles", async () => {
+		detectCornerMarkers.mockReturnValueOnce(null);
+		const { onApply } = renderModal("perspective", null);
+		await stillLoaded();
+		fireEvent.click(
+			screen.getByRole("button", { name: "dialogs.cameraCalibration.detectMarkers" }),
+		);
+		expect(screen.getByRole("status")).toHaveTextContent(
+			"dialogs.cameraCalibration.markersNotFound",
+		);
+		fireEvent.click(apply());
+		expect(onApply.mock.calls[0][0].perspective.corners).toEqual([
+			{ x: 0.15, y: 0.15 },
+			{ x: 0.85, y: 0.15 },
+			{ x: 0.85, y: 0.85 },
+			{ x: 0.15, y: 0.85 },
+		]);
+	});
+
+	it("the marker message goes away once a handle moves", async () => {
+		detectCornerMarkers.mockReturnValueOnce(null);
+		renderModal("perspective", null);
+		await stillLoaded();
+		const detect = () =>
+			fireEvent.click(
+				screen.getByRole("button", { name: "dialogs.cameraCalibration.detectMarkers" }),
+			);
+		detect();
+		expect(screen.getByRole("status")).toHaveTextContent(
+			"dialogs.cameraCalibration.markersNotFound",
+		);
+		fireEvent.keyDown(screen.getByTestId("calibration-handle-1"), { key: "ArrowLeft" });
+		expect(screen.getByRole("status")).toBeEmptyDOMElement();
+
+		// A drag that starts clears it too, before the pointer even moves.
+		detectCornerMarkers.mockReturnValueOnce(null);
+		detect();
+		expect(screen.getByRole("status")).toHaveTextContent(
+			"dialogs.cameraCalibration.markersNotFound",
+		);
+		const frame = screen.getByTestId("calibration-frame");
+		vi.spyOn(frame, "getBoundingClientRect").mockReturnValue(new DOMRect(0, 0, 100, 80));
+		// Corner 0 sits at 15 % / 15 % of the frame.
+		fireEvent.pointerDown(frame, { clientX: 15, clientY: 12 });
+		expect(screen.getByRole("status")).toBeEmptyDOMElement();
+		fireEvent(window, new Event("pointerup"));
+	});
+
+	it("print hands the translated texts to the sheet", async () => {
+		renderModal("perspective", null);
+		await stillLoaded();
+		fireEvent.click(
+			screen.getByRole("button", { name: "dialogs.cameraCalibration.printMarkerSheet" }),
+		);
+		expect(printMarkerSheet).toHaveBeenCalledWith({
+			instruction: "dialogs.cameraCalibration.markerSheetInstruction",
+			labels: [
+				"0 – dialogs.cameraCalibration.corners.topLeft",
+				"1 – dialogs.cameraCalibration.corners.topRight",
+				"2 – dialogs.cameraCalibration.corners.bottomRight",
+				"3 – dialogs.cameraCalibration.corners.bottomLeft",
+			],
+		});
+	});
+
+	it("reset removes the stored perspective", async () => {
+		const { onApply } = renderModal("perspective", {
+			perspective: {
+				corners: [
+					{ x: 0.1, y: 0.1 },
+					{ x: 0.9, y: 0.1 },
+					{ x: 0.9, y: 0.9 },
+					{ x: 0.1, y: 0.9 },
+				],
+				aspect: 2,
+			},
+		});
+		await stillLoaded();
+		fireEvent.click(screen.getByRole("button", { name: "dialogs.cameraCalibration.reset" }));
+		expect(onApply).toHaveBeenCalledWith({ perspective: undefined });
+	});
+
+	it("perspective mode says a stored crop is ignored", async () => {
+		renderModal("perspective", { crop: { x: 0.1, y: 0.1, width: 0.5, height: 0.5 } });
+		await stillLoaded();
+		expect(screen.getByText("dialogs.cameraCalibration.cropIgnored")).toBeInTheDocument();
+	});
+
+	it("says nothing about the crop when there is none", async () => {
+		renderModal("perspective", null);
+		await stillLoaded();
+		expect(screen.queryByText("dialogs.cameraCalibration.cropIgnored")).toBeNull();
+	});
+
+	it("crop mode does not show the perspective note", async () => {
+		renderModal("crop", { crop: { x: 0.1, y: 0.1, width: 0.5, height: 0.5 } });
+		await stillLoaded();
+		expect(screen.queryByText("dialogs.cameraCalibration.cropIgnored")).toBeNull();
+	});
+
+	it("the caller can report camera 1's crop, which lives outside the settings", async () => {
+		render(
+			<CameraCalibrationModal
+				open
+				camera={{ ...CAMERA, index: 0 }}
+				mode="perspective"
+				initial={null}
+				hasCrop
+				onApply={vi.fn()}
+				onClose={vi.fn()}
+			/>,
+		);
+		await stillLoaded();
+		expect(screen.getByText("dialogs.cameraCalibration.cropIgnored")).toBeInTheDocument();
+	});
+});
diff --git a/src/components/ai-edition/CameraCalibrationModal.tsx b/src/components/ai-edition/CameraCalibrationModal.tsx
new file mode 100644
index 000000000..d0e0438db
--- /dev/null
+++ b/src/components/ai-edition/CameraCalibrationModal.tsx
@@ -0,0 +1,711 @@
+// The camera calibration dialog. Perspective mode: four corner handles on a still of the camera,
+// dragged with the pointer or nudged with the arrow keys, a loupe for the corner being placed,
+// the target format and margin, and a live preview of the corrected picture. "Detect markers"
+// places the corners on the four printed markers (`arucoMarkers.ts`); "Print marker sheet"
+// prints them (`markerSheet.ts`). Crop mode: a rectangle with corner and edge handles. Built on
+// `ModalShell`, so the editor's shortcuts and undo stay blocked while it is open; Apply hands
+// back one settings patch (one undo step).
+
+import {
+	type CSSProperties,
+	type KeyboardEvent as ReactKeyboardEvent,
+	type PointerEvent as ReactPointerEvent,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+} from "react";
+import type {
+	CameraPerspective,
+	CameraPoint,
+	CameraSettings,
+	CropRegion,
+} from "@/components/video-editor/types";
+import { useScopedT } from "@/contexts/I18nContext";
+import {
+	type Corners,
+	type CropEdges,
+	clampCrop,
+	clampPoint,
+	insetCorners,
+	isFullCrop,
+	isValidQuad,
+	loupeSourceRect,
+	moveCrop,
+	nearestHandle,
+	previewSize,
+	renderRectified,
+	resizeCrop,
+} from "@/lib/ai-edition/timeline/calibrationGeometry";
+import { grabFrame } from "@/lib/ai-edition/timeline/grabFrame";
+import { detectCornerMarkers } from "@/lib/arucoMarkers";
+import { printMarkerSheet } from "@/lib/markerSheet";
+import type { CalibrationMode } from "./CamerasSection";
+import { previewBoxStyle } from "./cropDraft";
+import { ModalShell } from "./Modals";
+import styles from "./NewEditorShell.module.css";
+import { ChoiceRow } from "./RightPanes";
+
+/** The camera being calibrated and the still it is calibrated on. */
+export interface CalibrationCamera {
+	/** 0 = camera 1. */
+	index: number;
+	label: string;
+	/** Video URL of the camera's file. */
+	src: string;
+	/** Time of that file shown by the playhead. */
+	timeSec: number;
+}
+
+export interface CameraCalibrationModalProps {
+	open: boolean;
+	camera: CalibrationCamera;
+	mode: CalibrationMode;
+	/** The camera's stored settings; the dialog starts from them. */
+	initial: CameraSettings | null;
+	/** The camera has a crop, which a perspective replaces. Camera 1 keeps its crop outside
+	 *  `initial`, so the caller says; defaults to `initial.crop`. */
+	hasCrop?: boolean;
+	/** The change to store (a key set to `undefined` removes it); called at most once. */
+	onApply: (patch: Partial<CameraSettings>) => void;
+	onClose: () => void;
+}
+
+type FormatId = "a4Portrait" | "a4Landscape" | "wide" | "standard" | "square" | "free";
+
+const FORMATS: ReadonlyArray<{ id: FormatId; aspect: number | null }> = [
+	{ id: "a4Portrait", aspect: 210 / 297 },
+	{ id: "a4Landscape", aspect: 297 / 210 },
+	{ id: "wide", aspect: 16 / 9 },
+	{ id: "standard", aspect: 4 / 3 },
+	{ id: "square", aspect: 1 },
+	{ id: "free", aspect: null },
+];
+
+const MIN_ASPECT = 0.1;
+const MAX_ASPECT = 10;
+const MAX_MARGIN_PCT = 20;
+/** How far from a corner (screen px) a press still grabs it. */
+const HANDLE_RADIUS_PX = 24;
+const LOUPE_SIZE_PX = 120;
+const LOUPE_ZOOM = 4;
+const PREVIEW_LONG_SIDE_PX = 320;
+/** One arrow press in crop mode, as a fraction of the image. */
+const CROP_STEP = 0.01;
+
+const CORNER_KEYS = ["topLeft", "topRight", "bottomRight", "bottomLeft"] as const;
+const CROP_CORNERS = ["nw", "ne", "sw", "se"] as const;
+const CROP_EDGES = ["n", "s", "w", "e"] as const;
+const FULL_CROP: CropRegion = { x: 0, y: 0, width: 1, height: 1 };
+
+function formatOf(aspect: number): FormatId {
+	const match = FORMATS.find((f) => f.aspect !== null && Math.abs(f.aspect - aspect) < 1e-3);
+	return match?.id ?? "free";
+}
+
+function parseAspect(text: string): number | null {
+	const value = Number(text.replace(",", "."));
+	return Number.isFinite(value) && value >= MIN_ASPECT && value <= MAX_ASPECT ? value : null;
+}
+
+function copyCorners(c: Corners): Corners {
+	return [{ ...c[0] }, { ...c[1] }, { ...c[2] }, { ...c[3] }];
+}
+
+/**
+ * A pointer drag on `window` until release or cancel; `onMove` gets the offset from the press.
+ * Returns a disposer that removes the listeners early (the dialog closing mid-drag).
+ */
+function trackDrag(e: ReactPointerEvent, onMove: (dxPx: number, dyPx: number) => void) {
+	const startX = e.clientX;
+	const startY = e.clientY;
+	const move = (ev: PointerEvent) => onMove(ev.clientX - startX, ev.clientY - startY);
+	const stop = () => {
+		window.removeEventListener("pointermove", move);
+		window.removeEventListener("pointerup", stop);
+		window.removeEventListener("pointercancel", stop);
+	};
+	window.addEventListener("pointermove", move);
+	window.addEventListener("pointerup", stop);
+	window.addEventListener("pointercancel", stop);
+	return stop;
+}
+
+export function CameraCalibrationModal({
+	open,
+	camera,
+	mode,
+	initial,
+	hasCrop = initial?.crop != null,
+	onApply,
+	onClose,
+}: CameraCalibrationModalProps) {
+	const t = useScopedT("dialogs");
+	const tc = useScopedT("common");
+	// The dialog is mounted per opening, so the stored settings seed the draft once.
+	const stored = initial?.perspective;
+	const [corners, setCorners] = useState<Corners>(() =>
+		stored ? copyCorners(stored.corners) : insetCorners(),
+	);
+	const [format, setFormat] = useState<FormatId>(() =>
+		stored ? formatOf(stored.aspect) : "a4Landscape",
+	);
+	const [freeAspect, setFreeAspect] = useState(() =>
+		stored ? String(Math.round(stored.aspect * 1000) / 1000) : "1.5",
+	);
+	const [marginPct, setMarginPct] = useState(() => Math.round((stored?.margin ?? 0) * 100));
+	const [crop, setCrop] = useState<CropRegion>(() => initial?.crop ?? FULL_CROP);
+	const [image, setImage] = useState<ImageData | null>(null);
+	const [loadFailed, setLoadFailed] = useState(false);
+	const [activeHandle, setActiveHandle] = useState<number | null>(null);
+	const [markerResult, setMarkerResult] = useState<"found" | "notFound" | null>(null);
+
+	const frameRef = useRef<HTMLDivElement | null>(null);
+	const stillRef = useRef<HTMLCanvasElement | null>(null);
+	const loupeRef = useRef<HTMLCanvasElement | null>(null);
+	const previewRef = useRef<HTMLCanvasElement | null>(null);
+	const handleRefs = useRef<Array<HTMLButtonElement | null>>([]);
+	// The running drag's disposer: a new drag or unmounting ends the previous one.
+	const stopDragRef = useRef<(() => void) | null>(null);
+
+	useEffect(
+		() => () => {
+			stopDragRef.current?.();
+			stopDragRef.current = null;
+		},
+		[],
+	);
+
+	// The marker message describes the corners as detected; any manual change makes it stale.
+	const startDrag = (e: ReactPointerEvent, onMove: (dxPx: number, dyPx: number) => void) => {
+		setMarkerResult(null);
+		stopDragRef.current?.();
+		stopDragRef.current = trackDrag(e, onMove);
+	};
+
+	// The still, at full resolution.
+	useEffect(() => {
+		let cancelled = false;
+		setImage(null);
+		setLoadFailed(false);
+		grabFrame(camera.src, camera.timeSec)
+			.then((data) => {
+				if (!cancelled) setImage(data);
+			})
+			.catch(() => {
+				if (!cancelled) setLoadFailed(true);
+			});
+		return () => {
+			cancelled = true;
+		};
+	}, [camera.src, camera.timeSec]);
+
+	// Paint the still. No 2D context (jsdom) leaves the canvas blank; the handles still work.
+	useEffect(() => {
+		const canvas = stillRef.current;
+		if (!canvas || !image) return;
+		canvas.width = image.width;
+		canvas.height = image.height;
+		canvas.getContext("2d")?.putImageData(image, 0, 0);
+	}, [image]);
+
+	const aspect =
+		format === "free"
+			? parseAspect(freeAspect)
+			: (FORMATS.find((f) => f.id === format)?.aspect ?? null);
+	const margin = marginPct / 100;
+	const quadValid = isValidQuad(corners);
+	// Memoized: the preview resamples whenever this object changes, not on every render.
+	const perspective = useMemo<CameraPerspective | null>(
+		() =>
+			quadValid && aspect !== null ? { corners, aspect, ...(margin > 0 ? { margin } : {}) } : null,
+		[corners, aspect, margin, quadValid],
+	);
+	const preview = previewSize(aspect ?? 1, PREVIEW_LONG_SIDE_PX);
+
+	// The corrected picture, resampled on every change of the corners, format or margin.
+	useEffect(() => {
+		if (mode !== "perspective") return;
+		const canvas = previewRef.current;
+		const ctx = canvas?.getContext("2d");
+		if (!canvas || !ctx) return;
+		ctx.clearRect(0, 0, canvas.width, canvas.height);
+		if (!image || !perspective) return;
+		const pixels = renderRectified(image, perspective, canvas.width, canvas.height);
+		if (pixels) ctx.putImageData(new ImageData(pixels, canvas.width, canvas.height), 0, 0);
+	}, [mode, image, perspective]);
+
+	// The loupe: the area under the active corner, magnified, crisp pixels and a crosshair.
+	useEffect(() => {
+		const canvas = loupeRef.current;
+		const source = stillRef.current;
+		const ctx = canvas?.getContext("2d");
+		if (!canvas || !source || !ctx || !image || activeHandle === null) return;
+		const c = corners[activeHandle];
+		const center = { x: c.x * image.width, y: c.y * image.height };
+		const r = loupeSourceRect(center, image.width, image.height, LOUPE_SIZE_PX, LOUPE_ZOOM);
+		ctx.imageSmoothingEnabled = false;
+		ctx.clearRect(0, 0, LOUPE_SIZE_PX, LOUPE_SIZE_PX);
+		ctx.drawImage(source, r.x, r.y, r.width, r.height, 0, 0, LOUPE_SIZE_PX, LOUPE_SIZE_PX);
+		const cx = ((center.x - r.x) / r.width) * LOUPE_SIZE_PX;
+		const cy = ((center.y - r.y) / r.height) * LOUPE_SIZE_PX;
+		ctx.strokeStyle = "rgb(255 80 80)";
+		ctx.lineWidth = 1;
+		ctx.beginPath();
+		ctx.moveTo(cx, 0);
+		ctx.lineTo(cx, LOUPE_SIZE_PX);
+		ctx.moveTo(0, cy);
+		ctx.lineTo(LOUPE_SIZE_PX, cy);
+		ctx.stroke();
+	}, [image, corners, activeHandle]);
+
+	const setCorner = (index: number, p: CameraPoint) => {
+		setMarkerResult(null);
+		setCorners((prev) => {
+			const next = copyCorners(prev);
+			next[index] = clampPoint(p);
+			return next;
+		});
+	};
+
+	// A press anywhere near a corner grabs it, so a corner is found without aiming at its dot.
+	const onFramePointerDown = (e: ReactPointerEvent) => {
+		const frame = frameRef.current;
+		if (!frame) return;
+		const r = frame.getBoundingClientRect();
+		if (r.width <= 0 || r.height <= 0) return;
+		const points = corners.map((c) => ({ x: c.x * r.width, y: c.y * r.height }));
+		const hit = nearestHandle(
+			points,
+			{ x: e.clientX - r.left, y: e.clientY - r.top },
+			HANDLE_RADIUS_PX,
+		);
+		if (hit === null) return;
+		e.preventDefault();
+		handleRefs.current[hit]?.focus();
+		setActiveHandle(hit);
+		const start = corners[hit];
+		startDrag(e, (dx, dy) =>
+			setCorner(hit, { x: start.x + dx / r.width, y: start.y + dy / r.height }),
+		);
+	};
+
+	// The arrows move the focused corner by one image pixel, ten with Shift.
+	const onHandleKeyDown = (index: number) => (e: ReactKeyboardEvent) => {
+		const dx = e.key === "ArrowLeft" ? -1 : e.key === "ArrowRight" ? 1 : 0;
+		const dy = e.key === "ArrowUp" ? -1 : e.key === "ArrowDown" ? 1 : 0;
+		if (dx === 0 && dy === 0) return;
+		// The editor shell seeks on the arrows, from window: keep them here.
+		e.preventDefault();
+		e.nativeEvent.stopPropagation();
+		const step = e.shiftKey ? 10 : 1;
+		const c = corners[index];
+		setCorner(index, {
+			x: c.x + (dx * step) / (image?.width ?? 1000),
+			y: c.y + (dy * step) / (image?.height ?? 1000),
+		});
+	};
+
+	const startCropMove = (e: ReactPointerEvent) => {
+		const frame = frameRef.current;
+		if (!frame) return;
+		e.preventDefault();
+		e.stopPropagation();
+		const r = frame.getBoundingClientRect();
+		if (r.width <= 0 || r.height <= 0) return;
+		const start = crop;
+		startDrag(e, (dx, dy) => setCrop(moveCrop(start, dx / r.width, dy / r.height)));
+	};
+
+	const startCropResize = (edges: CropEdges) => (e: ReactPointerEvent) => {
+		const frame = frameRef.current;
+		if (!frame) return;
+		e.preventDefault();
+		e.stopPropagation();
+		const r = frame.getBoundingClientRect();
+		if (r.width <= 0 || r.height <= 0) return;
+		const start = crop;
+		startDrag(e, (dx, dy) => setCrop(resizeCrop(start, edges, dx / r.width, dy / r.height)));
+	};
+
+	// The arrows move the crop; Shift + the arrows resize it from its bottom-right corner.
+	const onCropKeyDown = (e: ReactKeyboardEvent) => {
+		const dx = e.key === "ArrowLeft" ? -1 : e.key === "ArrowRight" ? 1 : 0;
+		const dy = e.key === "ArrowUp" ? -1 : e.key === "ArrowDown" ? 1 : 0;
+		if (dx === 0 && dy === 0) return;
+		e.preventDefault();
+		e.nativeEvent.stopPropagation();
+		if (e.shiftKey) {
+			setCrop(
+				resizeCrop(crop, { right: dx !== 0, bottom: dy !== 0 }, dx * CROP_STEP, dy * CROP_STEP),
+			);
+			return;
+		}
+		setCrop(moveCrop(crop, dx * CROP_STEP, dy * CROP_STEP));
+	};
+
+	// The four printed markers place the corners; without all four the corners stay put.
+	const detectMarkers = () => {
+		if (!image) return;
+		const found = detectCornerMarkers(image);
+		if (found) setCorners(copyCorners(found));
+		setMarkerResult(found ? "found" : "notFound");
+	};
+
+	const printSheet = () => {
+		// Marker ID n belongs on corner n, the handles' order.
+		const label = (id: number) => `${id} – ${t(`cameraCalibration.corners.${CORNER_KEYS[id]}`)}`;
+		printMarkerSheet({
+			instruction: t("cameraCalibration.markerSheetInstruction"),
+			labels: [label(0), label(1), label(2), label(3)],
+		});
+	};
+
+	const isPerspective = mode === "perspective";
+	const canApply = isPerspective ? perspective !== null : true;
+	const hasStored = isPerspective ? Boolean(initial?.perspective) : Boolean(initial?.crop);
+
+	const apply = () => {
+		if (isPerspective) {
+			if (!perspective) return;
+			onApply({ perspective: { ...perspective, corners: copyCorners(perspective.corners) } });
+		} else {
+			const next = clampCrop(crop);
+			onApply({ crop: isFullCrop(next) ? undefined : next });
+		}
+		onClose();
+	};
+
+	// Reset removes the stored correction (or crop) altogether.
+	const reset = () => {
+		setMarkerResult(null);
+		onApply(isPerspective ? { perspective: undefined } : { crop: undefined });
+		onClose();
+	};
+
+	const imageAspect = image ? image.width / image.height : 16 / 9;
+	const title = isPerspective
+		? t("cameraCalibration.titlePerspective", { camera: camera.label })
+		: t("cameraCalibration.titleCrop", { camera: camera.label });
+	// The loupe sits in the corner away from the corner being placed.
+	const active = activeHandle === null ? null : corners[activeHandle];
+	const loupeOnRight = active !== null && active.x < 0.5 && active.y < 0.5;
+
+	return (
+		<ModalShell open={open} onClose={onClose} title={title} wide>
+			<p className={styles.hint} style={{ margin: "0 0 10px" }}>
+				{isPerspective ? t("cameraCalibration.perspectiveHelp") : t("cameraCalibration.cropHelp")}
+			</p>
+			{isPerspective && hasCrop ? (
+				<p className={styles.hint} style={{ margin: "0 0 10px" }}>
+					{t("cameraCalibration.cropIgnored")}
+				</p>
+			) : null}
+			<div
+				ref={frameRef}
+				data-testid="calibration-frame"
+				style={{ ...previewBoxStyle(imageAspect), touchAction: "none" }}
+				onPointerDown={isPerspective ? onFramePointerDown : undefined}
+			>
+				<canvas
+					ref={stillRef}
+					aria-hidden
+					style={{ position: "absolute", inset: 0, width: "100%", height: "100%" }}
+				/>
+				{image === null ? (
+					<p
+						className={styles.hint}
+						style={{ position: "absolute", inset: 0, display: "grid", placeItems: "center" }}
+					>
+						{loadFailed ? t("cameraCalibration.loadFailed") : t("cameraCalibration.loading")}
+					</p>
+				) : null}
+				{isPerspective ? (
+					<>
+						<svg
+							aria-hidden
+							viewBox="0 0 1 1"
+							preserveAspectRatio="none"
+							style={{ position: "absolute", inset: 0, width: "100%", height: "100%" }}
+						>
+							<polygon
+								points={corners.map((c) => `${c.x},${c.y}`).join(" ")}
+								fill={quadValid ? "rgb(80 160 255 / 0.15)" : "rgb(255 80 80 / 0.2)"}
+								stroke={quadValid ? "rgb(255 255 255 / 0.9)" : "rgb(255 80 80)"}
+								strokeWidth={1.5}
+								vectorEffect="non-scaling-stroke"
+							/>
+						</svg>
+						{corners.map((c, i) => (
+							<button
+								key={CORNER_KEYS[i]}
+								ref={(el) => {
+									handleRefs.current[i] = el;
+								}}
+								type="button"
+								data-testid={`calibration-handle-${i}`}
+								aria-label={t(`cameraCalibration.corners.${CORNER_KEYS[i]}`)}
+								aria-keyshortcuts="ArrowLeft ArrowRight ArrowUp ArrowDown"
+								onFocus={() => setActiveHandle(i)}
+								onBlur={() => setActiveHandle((a) => (a === i ? null : a))}
+								onKeyDown={onHandleKeyDown(i)}
+								style={{
+									position: "absolute",
+									left: `${c.x * 100}%`,
+									top: `${c.y * 100}%`,
+									width: 16,
+									height: 16,
+									padding: 0,
+									transform: "translate(-50%, -50%)",
+									borderRadius: "50%",
+									border: "2px solid #fff",
+									background: activeHandle === i ? "rgb(80 160 255)" : "rgb(0 0 0 / 0.5)",
+									cursor: "move",
+								}}
+							/>
+						))}
+						{activeHandle !== null && image ? (
+							<canvas
+								ref={loupeRef}
+								aria-label={t("cameraCalibration.loupe")}
+								width={LOUPE_SIZE_PX}
+								height={LOUPE_SIZE_PX}
+								style={{
+									position: "absolute",
+									top: 8,
+									...(loupeOnRight ? { right: 8 } : { left: 8 }),
+									width: LOUPE_SIZE_PX,
+									height: LOUPE_SIZE_PX,
+									border: "2px solid #fff",
+									borderRadius: 6,
+									background: "#000",
+									pointerEvents: "none",
+								}}
+							/>
+						) : null}
+					</>
+				) : (
+					<div
+						className={styles.cropRegion}
+						role="slider"
+						data-testid="calibration-crop"
+						aria-label={t("cameraCalibration.cropArea")}
+						aria-valuemin={0}
+						aria-valuemax={100}
+						aria-valuenow={Math.round(crop.width * 100)}
+						aria-valuetext={`${Math.round(crop.x * 100)}%, ${Math.round(crop.y * 100)}%, ${Math.round(crop.width * 100)}% × ${Math.round(crop.height * 100)}%`}
+						aria-keyshortcuts="Shift+ArrowLeft Shift+ArrowRight Shift+ArrowUp Shift+ArrowDown"
+						tabIndex={0}
+						onKeyDown={onCropKeyDown}
+						onPointerDown={startCropMove}
+						style={{
+							position: "absolute",
+							left: `${crop.x * 100}%`,
+							top: `${crop.y * 100}%`,
+							width: `${crop.width * 100}%`,
+							height: `${crop.height * 100}%`,
+							border: "1.5px solid rgb(255 255 255 / 0.9)",
+							borderRadius: 4,
+							boxShadow: "0 0 0 9999px var(--overlay-dark)",
+							cursor: "move",
+							touchAction: "none",
+							...({ "--bracket": "22px", "--bracket-w": "4px" } as CSSProperties),
+						}}
+					>
+						{CROP_CORNERS.map((corner) => (
+							<span
+								key={corner}
+								className={styles.framingHandle}
+								data-corner={corner}
+								onPointerDown={startCropResize({
+									top: corner.startsWith("n"),
+									bottom: corner.startsWith("s"),
+									left: corner.endsWith("w"),
+									right: corner.endsWith("e"),
+								})}
+							/>
+						))}
+						{CROP_EDGES.map((edge) => (
+							<span
+								key={edge}
+								className={styles.cropEdge}
+								data-edge={edge}
+								onPointerDown={startCropResize({
+									top: edge === "n",
+									bottom: edge === "s",
+									left: edge === "w",
+									right: edge === "e",
+								})}
+							/>
+						))}
+					</div>
+				)}
+			</div>
+
+			{isPerspective ? (
+				<div
+					style={{
+						display: "flex",
+						gap: 8,
+						flexWrap: "wrap",
+						alignItems: "center",
+						margin: "10px 0",
+					}}
+				>
+					<button
+						type="button"
+						className={`${styles.btn} ${styles.btnSecondary}`}
+						onClick={detectMarkers}
+						disabled={image === null}
+					>
+						{t("cameraCalibration.detectMarkers")}
+					</button>
+					<button
+						type="button"
+						className={`${styles.btn} ${styles.btnSecondary}`}
+						onClick={printSheet}
+					>
+						{t("cameraCalibration.printMarkerSheet")}
+					</button>
+					<p role="status" className={styles.hint} style={{ margin: 0, flex: "1 1 200px" }}>
+						{markerResult === "found"
+							? t("cameraCalibration.markersFound")
+							: markerResult === "notFound"
+								? t("cameraCalibration.markersNotFound")
+								: null}
+					</p>
+				</div>
+			) : null}
+
+			{isPerspective ? (
+				<div style={{ display: "flex", gap: 16, flexWrap: "wrap", alignItems: "flex-start" }}>
+					<div style={{ flex: "1 1 260px", display: "flex", flexDirection: "column", gap: 10 }}>
+						<span className={styles.fieldLabel}>{t("cameraCalibration.format")}</span>
+						<ChoiceRow<FormatId>
+							label={t("cameraCalibration.format")}
+							columns={3}
+							options={[
+								{ value: "a4Portrait", label: t("cameraCalibration.formats.a4Portrait") },
+								{ value: "a4Landscape", label: t("cameraCalibration.formats.a4Landscape") },
+								{ value: "wide", label: "16:9" },
+								{ value: "standard", label: "4:3" },
+								{ value: "square", label: "1:1" },
+								{ value: "free", label: t("cameraCalibration.formats.free") },
+							]}
+							value={format}
+							onChange={setFormat}
+						/>
+						{format === "free" ? (
+							<label style={{ display: "flex", gap: 8, alignItems: "center" }}>
+								<span className={styles.label}>{t("cameraCalibration.freeRatio")}</span>
+								<input
+									type="number"
+									inputMode="decimal"
+									min={MIN_ASPECT}
+									max={MAX_ASPECT}
+									step={0.01}
+									value={freeAspect}
+									onChange={(e) => setFreeAspect(e.target.value)}
+									aria-invalid={aspect === null}
+									aria-describedby={aspect === null ? "calibration-invalid-ratio" : undefined}
+									style={{ width: 80 }}
+								/>
+							</label>
+						) : null}
+						{format === "free" && aspect === null ? (
+							<p
+								id="calibration-invalid-ratio"
+								className={styles.hint}
+								role="alert"
+								style={{ margin: 0 }}
+							>
+								{t("cameraCalibration.invalidRatio", { min: MIN_ASPECT, max: MAX_ASPECT })}
+							</p>
+						) : null}
+						<label style={{ display: "flex", gap: 8, alignItems: "center" }}>
+							<span className={styles.label}>{t("cameraCalibration.margin")}</span>
+							<input
+								type="range"
+								min={0}
+								max={MAX_MARGIN_PCT}
+								step={1}
+								value={marginPct}
+								onChange={(e) => setMarginPct(Number(e.target.value))}
+								style={{ flex: 1 }}
+							/>
+							<span className={styles.label} style={{ fontVariantNumeric: "tabular-nums" }}>
+								{marginPct} %
+							</span>
+						</label>
+					</div>
+					<div style={{ flex: "none", display: "flex", flexDirection: "column", gap: 6 }}>
+						<span className={styles.fieldLabel}>{t("cameraCalibration.preview")}</span>
+						<canvas
+							ref={previewRef}
+							data-testid="calibration-preview"
+							aria-label={t("cameraCalibration.preview")}
+							width={preview.width}
+							height={preview.height}
+							style={{
+								width: preview.width,
+								maxWidth: "100%",
+								background: "#000",
+								borderRadius: 6,
+							}}
+						/>
+					</div>
+				</div>
+			) : null}
+
+			{isPerspective && !quadValid ? (
+				<p id="calibration-invalid" className={styles.hint} role="alert" style={{ marginTop: 10 }}>
+					{t("cameraCalibration.invalidQuad")}
+				</p>
+			) : null}
+
+			<div
+				style={{
+					display: "flex",
+					justifyContent: "space-between",
+					gap: 8,
+					marginTop: 14,
+					paddingTop: 12,
+					borderTop: "1px solid var(--border-soft)",
+				}}
+			>
+				<button
+					type="button"
+					className={`${styles.btn} ${styles.btnSecondary}`}
+					onClick={reset}
+					disabled={!hasStored}
+				>
+					{t("cameraCalibration.reset")}
+				</button>
+				<div style={{ display: "flex", gap: 8 }}>
+					<button
+						type="button"
+						className={`${styles.btn} ${styles.btnSecondary}`}
+						onClick={onClose}
+					>
+						{tc("actions.cancel")}
+					</button>
+					<button
+						type="button"
+						className={`${styles.btn} ${styles.btnPrimary}`}
+						onClick={apply}
+						disabled={!canApply}
+						aria-describedby={
+							isPerspective && !quadValid
+								? "calibration-invalid"
+								: isPerspective && aspect === null
+									? "calibration-invalid-ratio"
+									: undefined
+						}
+					>
+						{t("cameraCalibration.apply")}
+					</button>
+				</div>
+			</div>
+		</ModalShell>
+	);
+}
diff --git a/src/components/ai-edition/CamerasSection.test.tsx b/src/components/ai-edition/CamerasSection.test.tsx
new file mode 100644
index 000000000..a382aaa5f
--- /dev/null
+++ b/src/components/ai-edition/CamerasSection.test.tsx
@@ -0,0 +1,185 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import type { AxcutDocument } from "@/lib/ai-edition/schema";
+
+vi.mock("@/contexts/I18nContext", () => ({
+	useScopedT: (scope: string) => (key: string, vars?: Record<string, string | number>) =>
+		vars?.n !== undefined
+			? `${scope}.${key}#${vars.n}${vars.label ? `|${vars.label}` : ""}`
+			: `${scope}.${key}`,
+}));
+vi.mock("@/lib/ai-edition/timeline/grabFrame", () => ({
+	grabFrameDataUrl: vi.fn(() => Promise.resolve("data:image/png;base64,AAAA")),
+}));
+
+import { readFileSync } from "node:fs";
+import { act } from "@testing-library/react";
+import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
+import { grabFrameDataUrl } from "@/lib/ai-edition/timeline/grabFrame";
+import { CamerasSection, calibrationCameraAt, cameraHasCrop } from "./CamerasSection";
+
+const track = (sourcePath: string, extra: Record<string, unknown> = {}) => ({
+	sourcePath,
+	visible: true,
+	startMs: 0,
+	offsetMs: 0,
+	...extra,
+});
+
+function makeDoc(extraCameras: number): AxcutDocument {
+	return {
+		assets: [
+			{
+				id: "a1",
+				cameraTrack: track("C:/cam1.mp4"),
+				additionalCameraTracks: Array.from({ length: extraCameras }, (_, i) =>
+					track(`C:/cam${i + 2}.mp4`, { label: i === 0 ? "Desk" : "" }),
+				),
+			},
+		],
+		timeline: {
+			clips: [
+				{
+					id: "c1",
+					assetId: "a1",
+					sourceStartSec: 0,
+					sourceEndSec: 10,
+					timelineStartSec: 0,
+					timelineEndSec: 10,
+				},
+			],
+		},
+	} as unknown as AxcutDocument;
+}
+
+const render2 = (extra: number, setCameraSettings = vi.fn(), onOpenCalibration = vi.fn()) => {
+	render(
+		<CamerasSection
+			document={makeDoc(extra)}
+			playheadSec={2}
+			cameraSettings={[]}
+			setCameraSettings={setCameraSettings}
+			onOpenCalibration={onOpenCalibration}
+		/>,
+	);
+	return { setCameraSettings, onOpenCalibration };
+};
+
+describe("CamerasSection", () => {
+	it("lists every camera of the clip", () => {
+		render2(2);
+		expect(screen.getByTestId("camera-row-0")).toHaveTextContent("settings.cameras.cameraN#1");
+		expect(screen.getByTestId("camera-row-1")).toHaveTextContent(
+			"settings.cameras.cameraNamed#2|Desk",
+		);
+		expect(screen.getByTestId("camera-row-2")).toHaveTextContent("settings.cameras.cameraN#3");
+	});
+
+	it("camera 1 offers only the perspective", () => {
+		const { onOpenCalibration } = render2(1);
+		const row = screen.getByTestId("camera-row-0");
+		expect(row).toHaveTextContent("settings.cameras.camera1Hint");
+		expect(row.querySelectorAll("button")).toHaveLength(1);
+		fireEvent.click(row.querySelector("button") as Element);
+		expect(onOpenCalibration).toHaveBeenCalledWith(0, "perspective");
+	});
+
+	it("rotating camera 2 calls setCameraSettings", () => {
+		const { setCameraSettings, onOpenCalibration } = render2(1);
+		const row = screen.getByTestId("camera-row-1");
+		fireEvent.click(
+			row.querySelector("button[aria-pressed]:not([aria-pressed='true'])") as Element,
+		);
+		expect(setCameraSettings).toHaveBeenCalledWith(1, { rotation: 180 });
+		const buttons = Array.from(row.querySelectorAll("button"));
+		fireEvent.click(buttons.find((b) => b.textContent === "settings.cameras.crop") as Element);
+		expect(onOpenCalibration).toHaveBeenCalledWith(1, "crop");
+	});
+
+	it("follows the playhead from the store without a prop", async () => {
+		vi.useFakeTimers();
+		useProjectStore.setState({ currentTimeSec: 1 });
+		render(
+			<CamerasSection document={makeDoc(0)} cameraSettings={[]} setCameraSettings={vi.fn()} />,
+		);
+		act(() => {
+			useProjectStore.setState({ currentTimeSec: 4 });
+		});
+		act(() => {
+			vi.advanceTimersByTime(300);
+		});
+		expect(vi.mocked(grabFrameDataUrl).mock.calls.at(-1)?.[1]).toBe(4);
+		vi.useRealTimers();
+	});
+
+	it("keeps the playhead subscription out of LayoutPane", () => {
+		const source = readFileSync("src/components/ai-edition/RightPanes.tsx", "utf8");
+		const start = source.indexOf("export function LayoutPane(");
+		const end = source.indexOf("/** The tightest the frame gets");
+		expect(source.slice(start, end)).not.toContain("currentTimeSec");
+	});
+
+	it("finds the calibration still of a camera at the playhead", () => {
+		const t = (key: string, vars?: Record<string, string | number>) =>
+			vars?.n !== undefined ? `${key}#${vars.n}${vars.label ? `|${vars.label}` : ""}` : key;
+		const doc = makeDoc(1);
+		const desk = calibrationCameraAt(doc, 2, 1, t);
+		expect(desk).toMatchObject({ index: 1, label: "cameras.cameraNamed#2|Desk", timeSec: 2 });
+		expect(desk?.src).toMatch(/^file:\/\/.*cam2\.mp4$/);
+		expect(calibrationCameraAt(doc, 2, 0, t)?.label).toBe("cameras.cameraN#1");
+		// No such camera, or no document: nothing to calibrate.
+		expect(calibrationCameraAt(doc, 2, 3, t)).toBeNull();
+		expect(calibrationCameraAt(null, 2, 0, t)).toBeNull();
+	});
+
+	it("a perspective disables the crop with a hint", () => {
+		const onOpenCalibration = vi.fn();
+		render(
+			<CamerasSection
+				document={makeDoc(1)}
+				playheadSec={2}
+				cameraSettings={[
+					null,
+					{
+						perspective: {
+							corners: [
+								{ x: 0.1, y: 0.1 },
+								{ x: 0.9, y: 0.1 },
+								{ x: 0.9, y: 0.9 },
+								{ x: 0.1, y: 0.9 },
+							],
+							aspect: 1.5,
+						},
+					},
+				]}
+				setCameraSettings={vi.fn()}
+				onOpenCalibration={onOpenCalibration}
+			/>,
+		);
+		const row = screen.getByTestId("camera-row-1");
+		const crop = screen.getByRole("button", { name: "settings.cameras.crop" });
+		expect(crop).toBeDisabled();
+		expect(row).toHaveTextContent("settings.cameras.cropOffWithPerspective");
+		fireEvent.click(crop);
+		expect(onOpenCalibration).not.toHaveBeenCalled();
+	});
+
+	it("without a perspective the crop stays available and no hint shows", () => {
+		render2(1);
+		expect(screen.getByRole("button", { name: "settings.cameras.crop" })).toBeEnabled();
+		expect(screen.queryByText("settings.cameras.cropOffWithPerspective")).toBeNull();
+	});
+
+	it("knows whether a camera has a crop", () => {
+		const crop = { x: 0.1, y: 0.1, width: 0.5, height: 0.5 };
+		expect(cameraHasCrop(null, [null, { crop }], 1)).toBe(true);
+		expect(cameraHasCrop(null, [null, { mirror: true }], 1)).toBe(false);
+		const withCamera1Crop = (webcamCropRegion: unknown) =>
+			({ legacyEditor: { webcamCropRegion } }) as unknown as AxcutDocument;
+		expect(cameraHasCrop(withCamera1Crop(crop), [], 0)).toBe(true);
+		expect(cameraHasCrop(withCamera1Crop({ x: 0, y: 0, width: 1, height: 1 }), [], 0)).toBe(false);
+		expect(cameraHasCrop(makeDoc(0), [], 0)).toBe(false);
+	});
+});
diff --git a/src/components/ai-edition/CamerasSection.tsx b/src/components/ai-edition/CamerasSection.tsx
new file mode 100644
index 000000000..92585ae43
--- /dev/null
+++ b/src/components/ai-edition/CamerasSection.tsx
@@ -0,0 +1,245 @@
+// The "Cameras" section of the layout pane: every camera of the clip under the playhead, with
+// a thumbnail and the per-camera settings. Camera 1 keeps its rotation, mirror and crop in
+// the controls above (older fields), so its row only offers the perspective correction.
+
+import { useEffect, useMemo, useState } from "react";
+import { toFileUrl } from "@/components/video-editor/projectPersistence";
+import type { CameraSettings, CropRegion } from "@/components/video-editor/types";
+import { useScopedT } from "@/contexts/I18nContext";
+import type { AxcutDocument } from "@/lib/ai-edition/schema";
+import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
+import { assetAdditionalCameraSources, assetCameraSource } from "@/lib/ai-edition/timeline/camera";
+import { camerasForClipAt, type ProjectCamera } from "@/lib/ai-edition/timeline/cameraList";
+import { grabFrameDataUrl } from "@/lib/ai-edition/timeline/grabFrame";
+import { locateVirtualPosition } from "@/lib/ai-edition/timeline/virtual-preview";
+import type { CameraRotation } from "@/lib/cameraOrientation";
+import styles from "./NewEditorShell.module.css";
+import { ChoiceRow, Toggle } from "./RightPanes";
+
+/** What the calibration dialog edits: the picture's crop, or its perspective. */
+export type CalibrationMode = "crop" | "perspective";
+
+const THUMBNAIL_SIDE = 96;
+/** The playhead moves every frame during playback; a still is only worth grabbing once it rests. */
+const THUMBNAIL_DEBOUNCE_MS = 250;
+
+export interface CamerasSectionProps {
+	document: AxcutDocument | null;
+	/** Overrides the playhead on the ruler; by default it is read from the project store here, so
+	 *  only this section re-renders while the playhead moves. */
+	playheadSec?: number;
+	/** `legacyEditor.cameraSettings`, normalized: index 0 = camera 1. */
+	cameraSettings: (CameraSettings | null)[];
+	setCameraSettings: (index: number, patch: Partial<CameraSettings> | null) => void | Promise<void>;
+	/** Opens the calibration dialog for a camera. */
+	onOpenCalibration?: (cameraIndex: number, mode: CalibrationMode) => void;
+}
+
+export type CameraStill = { src: string; timeSec: number };
+
+/** Where each camera's file is, and which time of it the playhead shows. */
+export function stillsAt(
+	document: AxcutDocument | null,
+	playheadSec: number,
+): Map<number, CameraStill> {
+	const stills = new Map<number, CameraStill>();
+	if (!document) return stills;
+	const position = locateVirtualPosition(document.timeline.clips, playheadSec);
+	if (!position) return stills;
+	const asset = document.assets.find((a) => a.id === position.clip.assetId);
+	const sources = [assetCameraSource(asset), ...assetAdditionalCameraSources(asset)];
+	sources.forEach((source, index) => {
+		if (!source.path) return;
+		const src = /^(https?|blob|data):/.test(source.path) ? source.path : toFileUrl(source.path);
+		stills.set(index, { src, timeSec: Math.max(0, position.sourceTimeSec - source.offsetSec) });
+	});
+	return stills;
+}
+
+/**
+ * Whether a camera has a crop stored. Camera 1 keeps its crop in `webcamCropRegion` (a
+ * full-frame rect means none); the others in `cameraSettings[k].crop`.
+ */
+export function cameraHasCrop(
+	document: AxcutDocument | null,
+	cameraSettings: (CameraSettings | null)[],
+	index: number,
+): boolean {
+	if (index !== 0) return cameraSettings[index]?.crop != null;
+	const legacy = document?.legacyEditor as Record<string, unknown> | null | undefined;
+	const crop = legacy?.webcamCropRegion as Partial<CropRegion> | undefined;
+	if (!crop) return false;
+	const coversFrame = (v: unknown) => typeof v !== "number" || v >= 1 - 1e-6;
+	return !(coversFrame(crop.width) && coversFrame(crop.height));
+}
+
+/** The camera the calibration dialog opens on: its label and its still at the playhead. */
+export function calibrationCameraAt(
+	document: AxcutDocument | null,
+	playheadSec: number,
+	index: number,
+	t: (key: string, vars?: Record<string, string | number>) => string,
+): { index: number; label: string; src: string; timeSec: number } | null {
+	if (!document) return null;
+	const camera = camerasForClipAt(document, playheadSec, t).find((c) => c.index === index);
+	const still = stillsAt(document, playheadSec).get(index);
+	if (!camera?.available || !still) return null;
+	return { index, label: camera.label, ...still };
+}
+
+function CameraThumbnail({ still, label }: { still: CameraStill | undefined; label: string }) {
+	const [url, setUrl] = useState<string | null>(null);
+	const src = still?.src;
+	const timeSec = still?.timeSec;
+	useEffect(() => {
+		if (src === undefined || timeSec === undefined) {
+			setUrl(null);
+			return;
+		}
+		let cancelled = false;
+		const timer = setTimeout(() => {
+			grabFrameDataUrl(src, timeSec, THUMBNAIL_SIDE)
+				.then((dataUrl) => {
+					if (!cancelled) setUrl(dataUrl);
+				})
+				.catch(() => {
+					if (!cancelled) setUrl(null);
+				});
+		}, THUMBNAIL_DEBOUNCE_MS);
+		return () => {
+			cancelled = true;
+			clearTimeout(timer);
+		};
+	}, [src, timeSec]);
+	return (
+		<div
+			style={{
+				width: THUMBNAIL_SIDE,
+				height: (THUMBNAIL_SIDE * 9) / 16,
+				flex: "none",
+				borderRadius: 6,
+				background: "var(--surface-hi)",
+				overflow: "hidden",
+			}}
+		>
+			{url ? (
+				<img
+					src={url}
+					alt={label}
+					style={{ width: "100%", height: "100%", objectFit: "cover", display: "block" }}
+				/>
+			) : null}
+		</div>
+	);
+}
+
+const BUTTON = `${styles.btn} ${styles.btnSecondary}`;
+
+export function CamerasSection({
+	document,
+	playheadSec: playheadOverride,
+	cameraSettings,
+	setCameraSettings,
+	onOpenCalibration,
+}: CamerasSectionProps) {
+	const ts = useScopedT("settings");
+	const storePlayheadSec = useProjectStore((s) => s.currentTimeSec);
+	const playheadSec = playheadOverride ?? storePlayheadSec;
+	const cameras: ProjectCamera[] = useMemo(
+		() => (document ? camerasForClipAt(document, playheadSec, ts) : []),
+		[document, playheadSec, ts],
+	);
+	const stills = useMemo(() => stillsAt(document, playheadSec), [document, playheadSec]);
+	if (cameras.length === 0) return null;
+	return (
+		<>
+			<div className={styles.sectionLabel}>{ts("cameras.title")}</div>
+			{cameras.map((camera) => {
+				const settings = cameraSettings[camera.index] ?? null;
+				const isFirst = camera.index === 0;
+				// A perspective replaces the crop at render, so the crop is not offered then.
+				const hasPerspective = settings?.perspective != null;
+				return (
+					<div
+						key={camera.index}
+						data-testid={`camera-row-${camera.index}`}
+						style={{
+							display: "flex",
+							flexDirection: "column",
+							gap: 8,
+							margin: "0 var(--sp-4) 14px",
+						}}
+					>
+						<div style={{ display: "flex", gap: 10, alignItems: "center" }}>
+							<CameraThumbnail
+								still={camera.available ? stills.get(camera.index) : undefined}
+								label={camera.label}
+							/>
+							<div style={{ minWidth: 0 }}>
+								<div className={styles.label}>{camera.label}</div>
+								{camera.available ? null : (
+									<p className={styles.hint}>{ts("cameras.unavailable")}</p>
+								)}
+							</div>
+						</div>
+						{isFirst ? <p className={styles.hint}>{ts("cameras.camera1Hint")}</p> : null}
+						{isFirst ? null : (
+							<>
+								<ChoiceRow<CameraRotation>
+									label={ts("cameras.rotation")}
+									options={[
+										{ value: 0, label: "0°" },
+										{ value: 180, label: "180°" },
+									]}
+									value={settings?.rotation ?? 0}
+									onChange={(rotation) => void setCameraSettings(camera.index, { rotation })}
+								/>
+								<div style={{ display: "flex", justifyContent: "space-between", gap: 12 }}>
+									<span className={styles.label}>{ts("cameras.mirror")}</span>
+									<Toggle
+										checked={settings?.mirror === true}
+										ariaLabel={ts("cameras.mirror")}
+										onChange={(mirror) => void setCameraSettings(camera.index, { mirror })}
+									/>
+								</div>
+							</>
+						)}
+						<div style={{ display: "flex", flexWrap: "wrap", gap: 8 }}>
+							{isFirst ? null : (
+								<button
+									type="button"
+									className={BUTTON}
+									disabled={!camera.available || hasPerspective}
+									title={hasPerspective ? ts("cameras.cropOffWithPerspective") : undefined}
+									onClick={() => onOpenCalibration?.(camera.index, "crop")}
+								>
+									{ts("cameras.crop")}
+								</button>
+							)}
+							<button
+								type="button"
+								className={BUTTON}
+								disabled={!camera.available}
+								onClick={() => onOpenCalibration?.(camera.index, "perspective")}
+							>
+								{ts("cameras.perspective")}
+							</button>
+							{!isFirst && settings ? (
+								<button
+									type="button"
+									className={BUTTON}
+									onClick={() => void setCameraSettings(camera.index, null)}
+								>
+									{ts("cameras.reset")}
+								</button>
+							) : null}
+						</div>
+						{!isFirst && hasPerspective ? (
+							<p className={styles.hint}>{ts("cameras.cropOffWithPerspective")}</p>
+						) : null}
+					</div>
+				);
+			})}
+		</>
+	);
+}
diff --git a/src/components/ai-edition/ExportDialog.params.test.tsx b/src/components/ai-edition/ExportDialog.params.test.tsx
index d78ad091c..76cc992c2 100644
--- a/src/components/ai-edition/ExportDialog.params.test.tsx
+++ b/src/components/ai-edition/ExportDialog.params.test.tsx
@@ -228,3 +228,47 @@ describe("ExportDialog format settings", () => {
 		}
 	});
 });
+
+describe("ExportDialog clip list", () => {
+	beforeEach(() => {
+		window.electronAPI = {
+			pickExportSavePath: vi.fn(async () => ({ path: "/tmp/out.mp4" })),
+			onNativeExportProgress: vi.fn(() => noop),
+		} as unknown as ElectronAPI;
+	});
+
+	afterEach(() => {
+		cleanup();
+		vi.clearAllMocks();
+	});
+
+	it("hands the native export the asset's extra cameras", async () => {
+		const withCameras: AxcutDocument = {
+			...DOC,
+			assets: [
+				{
+					...DOC.assets[0],
+					additionalCameraTracks: [
+						{ sourcePath: "/tmp/cam2.mp4", startMs: 500, offsetMs: 250, visible: true, label: "" },
+						{ sourcePath: "/tmp/cam3.mp4", startMs: 0, offsetMs: 0, visible: false, label: "" },
+					],
+				},
+			],
+		};
+		renderDialog(withCameras);
+		await exportMp4();
+		const clips = vi.mocked(exportMultiNative).mock.calls.at(-1)?.[0];
+		expect(clips?.[0]?.additionalCameras).toEqual([
+			{ path: "/tmp/cam2.mp4", offsetSec: 0.75 },
+			// A hidden track keeps its slot, so the indices stay aligned with the tracks.
+			{ path: "", offsetSec: 0 },
+		]);
+	});
+
+	it("sends no extra cameras for a one-camera asset", async () => {
+		renderDialog();
+		await exportMp4();
+		const clips = vi.mocked(exportMultiNative).mock.calls.at(-1)?.[0];
+		expect(clips?.[0]).not.toHaveProperty("additionalCameras");
+	});
+});
diff --git a/src/components/ai-edition/ExportDialog.tsx b/src/components/ai-edition/ExportDialog.tsx
index 47b08b08a..be340bb60 100644
--- a/src/components/ai-edition/ExportDialog.tsx
+++ b/src/components/ai-edition/ExportDialog.tsx
@@ -19,7 +19,7 @@ import {
 } from "@/lib/ai-edition/document/outputFormat";
 import type { AxcutDocument } from "@/lib/ai-edition/schema";
 import { getEditorSettings } from "@/lib/ai-edition/store/editorSettings";
-import { assetCameraSource } from "@/lib/ai-edition/timeline/camera";
+import { assetAdditionalCameraSources, assetCameraSource } from "@/lib/ai-edition/timeline/camera";
 import { resolveClipSourceEndSec } from "@/lib/ai-edition/timeline/clipDuration";
 import {
 	type ExportFormat,
@@ -117,6 +117,8 @@ function buildNativeClipList(document: AxcutDocument): CompositorClipInput[] {
 			return [];
 		}
 		const camera = assetCameraSource(asset);
+		// Cameras 2-4, only sent when the asset has any (same rule as `buildSceneDescription`).
+		const additionalCameras = assetAdditionalCameraSources(asset);
 		// sourceEndSec is optional in the schema (unknown until probed) — fall back through
 		// the single canonical precedence used by every consumer (clip.probe → asset.duration
 		// → timeline-length guess). See `resolveClipSourceEndSec` for the full order.
@@ -132,6 +134,7 @@ function buildNativeClipList(document: AxcutDocument): CompositorClipInput[] {
 				sourceEndSec,
 				webcamOffsetSec: camera.offsetSec,
 				hasAudio: true,
+				...(additionalCameras.length > 0 ? { additionalCameras } : {}),
 			},
 		];
 	});
diff --git a/src/components/ai-edition/NativeCompositorOverlay.test.tsx b/src/components/ai-edition/NativeCompositorOverlay.test.tsx
index 7c4c0f397..f776feab7 100644
--- a/src/components/ai-edition/NativeCompositorOverlay.test.tsx
+++ b/src/components/ai-edition/NativeCompositorOverlay.test.tsx
@@ -157,10 +157,31 @@ describe("NativeCompositorOverlay while playing", () => {
 
 		setPlayhead(8, true);
 
-		expect(native.setActiveClip).toHaveBeenCalledWith(7, "/take.mp4", "", 0, 1, 10);
+		expect(native.setActiveClip).toHaveBeenCalledWith(7, "/take.mp4", "", 0, 1, 10, []);
 		expect(native.setNativePlaying).not.toHaveBeenCalledWith(false);
 	});
 
+	it("sends the asset's extra cameras with the clip", async () => {
+		const document = makeDocument();
+		document.assets[0] = {
+			...document.assets[0],
+			additionalCameraTracks: [
+				{ sourcePath: "/cam-2.mp4", startMs: 500, offsetMs: 0, visible: true, label: "" },
+				{ sourcePath: "/cam-3.mp4", startMs: 0, offsetMs: 0, visible: false, label: "" },
+			],
+		};
+		useProjectStore.setState({ document });
+		await mountAtFirstClip();
+		publishNativePosition({ clipIndex: 0, sourceTimeSec: 4.9 }, now);
+
+		setPlayhead(8, true);
+
+		expect(native.setActiveClip).toHaveBeenCalledWith(7, "/take.mp4", "", 0, 1, 10, [
+			{ path: "/cam-2.mp4", offsetSec: 0.5 },
+			{ path: "", offsetSec: 0 },
+		]);
+	});
+
 	it("re-anchors a view that stays behind, once the gap holds", async () => {
 		await mountAtFirstClip();
 		// The view stalled 0.4 s behind the playhead, inside the first clip.
@@ -173,7 +194,7 @@ describe("NativeCompositorOverlay while playing", () => {
 		setPlayhead(2.52, true);
 
 		expect(native.setActiveClip).toHaveBeenCalledTimes(1);
-		expect(native.setActiveClip).toHaveBeenCalledWith(7, "/take.mp4", "", 0, 0, 2.52);
+		expect(native.setActiveClip).toHaveBeenCalledWith(7, "/take.mp4", "", 0, 0, 2.52, []);
 	});
 
 	// At 16× a frame that takes 30 ms to arrive shows the playhead 0.48 s of programme ago.
@@ -228,8 +249,8 @@ describe("NativeCompositorOverlay while playing", () => {
 			setPlayhead(time, false);
 		}
 
-		expect(native.setActiveClip).toHaveBeenCalledWith(7, "/take.mp4", "", 0, 0, 14.4);
-		expect(native.setActiveClip).toHaveBeenLastCalledWith(7, "/take.mp4", "", 0, 0, 14.4);
+		expect(native.setActiveClip).toHaveBeenCalledWith(7, "/take.mp4", "", 0, 0, 14.4, []);
+		expect(native.setActiveClip).toHaveBeenLastCalledWith(7, "/take.mp4", "", 0, 0, 14.4, []);
 	});
 
 	it("still sends the clip on a change while paused", async () => {
@@ -239,7 +260,7 @@ describe("NativeCompositorOverlay while playing", () => {
 
 		setPlayhead(6, false);
 
-		expect(native.setActiveClip).toHaveBeenCalledWith(7, "/take.mp4", "", 0, 1, 8);
+		expect(native.setActiveClip).toHaveBeenCalledWith(7, "/take.mp4", "", 0, 1, 8, []);
 	});
 
 	// An addon that reports no position cannot be read, so it is driven as before.
diff --git a/src/components/ai-edition/NativeCompositorOverlay.tsx b/src/components/ai-edition/NativeCompositorOverlay.tsx
index f3a90605b..84a67ce39 100644
--- a/src/components/ai-edition/NativeCompositorOverlay.tsx
+++ b/src/components/ai-edition/NativeCompositorOverlay.tsx
@@ -4,7 +4,7 @@ import { readSpeedRegions } from "@/lib/ai-edition/document/timeline";
 import { noteUiProbeClipSwitch } from "@/lib/ai-edition/perf/uiFrameProbe";
 import { getEditorSettings } from "@/lib/ai-edition/store/editorSettings";
 import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
-import { assetCameraSource } from "@/lib/ai-edition/timeline/camera";
+import { assetAdditionalCameraSources, assetCameraSource } from "@/lib/ai-edition/timeline/camera";
 import { findActiveSpeedRegion, type SpeedRegion } from "@/lib/ai-edition/timeline/speed";
 import { resolveNativePosition } from "@/lib/ai-edition/timeline/timelineMap";
 import {
@@ -279,6 +279,7 @@ export function NativeCompositorOverlay() {
 			camera.offsetSec,
 			activeClipIndex,
 			activeSourceTimeSec,
+			assetAdditionalCameraSources(asset),
 		)
 			.then(() => {
 				if (pendingTargetClipIdRef.current !== targetClipId) {
@@ -355,6 +356,7 @@ export function NativeCompositorOverlay() {
 			camera.offsetSec,
 			activeClipIndex,
 			activeSourceTimeSec,
+			assetAdditionalCameraSources(asset),
 		).catch((error: unknown) => {
 			console.warn("[compositor-view] re-anchoring the preview failed:", error);
 		});
diff --git a/src/components/ai-edition/NewEditorShell.module.css b/src/components/ai-edition/NewEditorShell.module.css
index 30b3c0947..162591937 100644
--- a/src/components/ai-edition/NewEditorShell.module.css
+++ b/src/components/ai-edition/NewEditorShell.module.css
@@ -763,6 +763,26 @@
 	visibility: hidden;
 	display: block;
 }
+.layoutPlace {
+	/* Move/resize hitbox of a layout section's camera window, over the native-drawn picture. */
+	position: absolute;
+	z-index: 3;
+	box-sizing: border-box;
+	border: 1px dashed var(--accent);
+	cursor: move;
+	touch-action: none;
+}
+.layoutPlaceHandle {
+	position: absolute;
+	width: 12px;
+	height: 12px;
+	transform: translate(-50%, -50%);
+	box-sizing: border-box;
+	border: 2px solid var(--accent);
+	border-radius: 2px;
+	background: #fff;
+	touch-action: none;
+}
 /* ─── transport bar (lives inside .timelineHead, next to the tool icons) ─ */
 .transport {
 	display: flex;
diff --git a/src/components/ai-edition/NewEditorShell.tsx b/src/components/ai-edition/NewEditorShell.tsx
index ee12161bd..032b878cd 100644
--- a/src/components/ai-edition/NewEditorShell.tsx
+++ b/src/components/ai-edition/NewEditorShell.tsx
@@ -2,6 +2,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { toast } from "sonner";
 import type { EditorProjectData } from "@/components/video-editor/projectPersistence";
 import { toFileUrl } from "@/components/video-editor/projectPersistence";
+import type { CameraSettings } from "@/components/video-editor/types";
 import { useEditorDialogActions } from "@/contexts/EditorDialogsContext";
 import { useScopedT } from "@/contexts/I18nContext";
 import { useShortcuts } from "@/contexts/ShortcutsContext";
@@ -33,6 +34,12 @@ import {
 } from "@/lib/ai-edition/schema";
 import { useMcpDocumentHost } from "@/lib/ai-edition/store/mcpDocumentHost";
 import { saveWithDeadline, useProjectStore } from "@/lib/ai-edition/store/projectStore";
+import {
+	copySourceKey,
+	pasteHitsCameraSection,
+	pasteIdPrefix,
+	pasteTarget,
+} from "@/lib/ai-edition/store/regionClipboardKinds";
 import {
 	useAssetTranscriptions,
 	useAutoTranscription,
@@ -44,6 +51,7 @@ import { future as redoStack, past as undoStack } from "@/lib/ai-edition/store/u
 import { useChatPromptBus } from "@/lib/ai-edition/store/useChatPromptBus";
 import { useSequentialTimelineOps } from "@/lib/ai-edition/store/useSequentialTimelineOps";
 import { useTimeline } from "@/lib/ai-edition/store/useTimeline";
+import { showCameraSectionOutcome } from "@/lib/ai-edition/timeline/cameraSectionNotice";
 import { isGeneratedAssetId } from "@/lib/ai-edition/timeline/clip-parts";
 import { mergeCloseCuts } from "@/lib/ai-edition/timeline/cut-breath";
 import { newRegionDurationSec } from "@/lib/ai-edition/timeline/newRegionDuration";
@@ -58,6 +66,8 @@ import { nativeBridgeClient } from "@/native";
 import type { AiEditionProjectSummary } from "@/native/contracts";
 import { resolveVisibleClips } from "@/native/sceneDescription";
 import { useNativePlaybackSync } from "@/native/useNativePlaybackSync";
+import { type CalibrationCamera, CameraCalibrationModal } from "./CameraCalibrationModal";
+import { type CalibrationMode, calibrationCameraAt, cameraHasCrop } from "./CamerasSection";
 import { ExportDialog } from "./ExportDialog";
 import { insertionsEnabled } from "./insertionsEnabled";
 import { ChatStripPanel } from "./LeftPanel";
@@ -192,6 +202,8 @@ export async function runLoadedMetadataWrite(
 
 export function NewEditorShell() {
 	const te = useScopedT("editor");
+	const tt = useScopedT("timeline");
+	const ts = useScopedT("settings");
 	useMcpDocumentHost();
 	const document = useProjectStore((s) => s.document);
 	const projectId = useProjectStore((s) => s.projectId);
@@ -266,6 +278,20 @@ export function NewEditorShell() {
 	// "Edit clip" rail button — a single shell-level instance instead of one
 	// mounted per trigger site.
 	const [editClipTarget, setEditClipTarget] = useState<AxcutClip | null>(null);
+	// The camera calibration dialog (perspective or crop), opened from the layout pane's camera
+	// list. The still is taken at the playhead as it opens; one instance for the editor.
+	const [calibration, setCalibration] = useState<{
+		camera: CalibrationCamera;
+		mode: CalibrationMode;
+	} | null>(null);
+	const openCalibration = useCallback(
+		(cameraIndex: number, mode: CalibrationMode) => {
+			const { document: doc, currentTimeSec } = useProjectStore.getState();
+			const camera = calibrationCameraAt(doc, currentTimeSec, cameraIndex, ts);
+			if (camera) setCalibration({ camera, mode });
+		},
+		[ts],
+	);
 	const [exportOpen, setExportOpen] = useState(false);
 	const [unsavedPrompt, setUnsavedPrompt] = useState<{
 		action: "close" | "new" | "open" | "record";
@@ -340,6 +366,15 @@ export function NewEditorShell() {
 		saveDocument,
 	});
 
+	// Every per-camera settings write (Cameras section toggles, reset, calibration apply) goes
+	// through the shared queue, so a toggle cannot race a calibration apply on a stale document.
+	const setTimelineCameraSettings = tl.setCameraSettings;
+	const setCameraSettingsQueued = useCallback(
+		(index: number, patch: Partial<CameraSettings> | null) =>
+			enqueueTimelineWrite(() => setTimelineCameraSettings(index, patch)),
+		[enqueueTimelineWrite, setTimelineCameraSettings],
+	);
+
 	const promptUnsaved = useCallback(
 		(action: "close" | "new" | "open" | "record"): Promise<UnsavedChoice> => {
 			if (!dirty) return Promise.resolve("discard");
@@ -1082,7 +1117,9 @@ export function NewEditorShell() {
 		// Land it at the playhead, keeping the copied length.
 		const timeMs = Math.round(useProjectStore.getState().currentTimeSec * 1000);
 		const src = snapshot.region as { startMs: number; endMs: number };
-		const prefix = snapshot.kind === "annotation" ? "ann" : snapshot.kind;
+		const prefix = pasteIdPrefix(snapshot.kind);
+		const target = pasteTarget(snapshot.kind);
+		if (!target) return;
 
 		// Audio re-ventilates through its own anchorer, which advances each
 		// fragment's source offset — the generic one would copy the offset into
@@ -1120,32 +1157,24 @@ export function NewEditorShell() {
 			() => createId(prefix),
 		);
 
-		if (snapshot.kind === "zoom") {
-			await saveDocument(
-				{
-					...doc,
-					zoomRanges: [...doc.zoomRanges, ...anchored] as typeof doc.zoomRanges,
-				},
-				{ history: true },
-			);
-		} else if (snapshot.kind === "annotation") {
-			await saveDocument(
-				{
-					...doc,
-					annotations: [...doc.annotations, ...anchored] as typeof doc.annotations,
-				},
-				{ history: true },
-			);
+		if (target.store === "document") {
+			const rows = doc[target.key] as unknown[];
+			await saveDocument({ ...doc, [target.key]: [...rows, ...anchored] }, { history: true });
 		} else {
-			// speed and cameraFullscreen are both plain spans on legacyEditor.
-			const key = snapshot.kind === "speed" ? "speedRegions" : "cameraFullscreenRegions";
 			const legacy = (doc.legacyEditor as Record<string, unknown>) ?? {};
-			const prev = (legacy[key] as unknown[]) ?? [];
+			// Full Camera and layout sections share one lane: a paste that would land on the
+			// other list is refused like an add is, instead of being dropped by the scene. A Full
+			// Camera over Full Camera is not refused: those merge, as they do on add.
+			if (
+				target.key !== "speedRegions" &&
+				pasteHitsCameraSection(legacy, target.key, pasted.startMs, pasted.endMs)
+			) {
+				showCameraSectionOutcome("occupied", tt);
+				return;
+			}
+			const prev = (legacy[target.key] as unknown[]) ?? [];
 			await saveDocument(
-				{
-					...doc,
-					legacyEditor: { ...legacy, [key]: [...prev, ...anchored] },
-				},
+				{ ...doc, legacyEditor: { ...legacy, [target.key]: [...prev, ...anchored] } },
 				{ history: true },
 			);
 		}
@@ -1153,7 +1182,7 @@ export function NewEditorShell() {
 		// `tl` belongs here now that the trim branch calls tl.addTrim: useTimeline
 		// returns a fresh object each render, so memoizing on saveDocument alone
 		// would paste through a callback holding a stale document.
-	}, [saveDocument, tl, te]);
+	}, [saveDocument, tl, te, tt]);
 
 	// Copy the SELECTED pill. Reads the same arrays the lanes render, so what gets
 	// copied is what the user is looking at — the old version dug into the raw
@@ -1197,14 +1226,9 @@ export function NewEditorShell() {
 			return;
 		}
 
-		const source =
-			sel.kind === "zoom"
-				? tl.zoomRegions
-				: sel.kind === "annotation"
-					? tl.annotationRegions
-					: sel.kind === "speed"
-						? tl.speedRegions
-						: tl.cameraFullscreenRegions;
+		const sourceKey = copySourceKey(sel.kind);
+		if (!sourceKey) return;
+		const source = tl[sourceKey];
 		const region = (source as Array<{ id: string }>).find((r) => r.id === sel.id);
 		if (!region) return;
 		copyRegion({ kind: sel.kind, region: region as unknown as Record<string, unknown> });
@@ -1386,7 +1410,9 @@ export function NewEditorShell() {
 			}
 			if (matchesShortcut(e, shortcuts.addCameraFullscreen, isMac)) {
 				e.preventDefault();
-				void tl.addCameraFullscreen(newRegionDurationSec());
+				void tl.addCameraFullscreen(newRegionDurationSec()).then((outcome) => {
+					showCameraSectionOutcome(outcome, tt);
+				});
 				return;
 			}
 
@@ -1433,6 +1459,7 @@ export function NewEditorShell() {
 		isMac,
 		togglePlay,
 		handleSeek,
+		tt,
 	]);
 
 	const showTimeline = mode !== "rec";
@@ -1622,6 +1649,12 @@ export function NewEditorShell() {
 									selectedZoomRegionId={tl.selection?.kind === "zoom" ? tl.selection.id : null}
 									onZoomFocusChange={tl.updateZoomFocusLive}
 									onZoomFocusCommit={() => void tl.commitZoomFocus()}
+									cameraLayoutRegions={tl.cameraLayoutRegions}
+									selectedLayoutRegionId={
+										tl.selection?.kind === "cameraLayout" ? tl.selection.id : null
+									}
+									onLayoutSlotRectLive={tl.updateLayoutSlotRectLive}
+									onLayoutSlotRectCommit={() => void tl.commitLayoutSlotRect()}
 									annotationRegions={tl.annotationRegions}
 									selectedAnnotationId={
 										tl.selection?.kind === "annotation" ? tl.selection.id : null
@@ -1655,6 +1688,8 @@ export function NewEditorShell() {
 								clips={tl.clips}
 								onEditClip={setEditClipTarget}
 								transcriptProps={transcriptProps}
+								onOpenCalibration={openCalibration}
+								setCameraSettings={setCameraSettingsQueued}
 							/>
 						</>
 					) : mode === "media" ? (
@@ -1746,6 +1781,18 @@ export function NewEditorShell() {
 					setEditClipTarget(null);
 				}}
 			/>
+			{calibration ? (
+				<CameraCalibrationModal
+					key={`${calibration.camera.index}-${calibration.mode}`}
+					open
+					camera={calibration.camera}
+					mode={calibration.mode}
+					initial={tl.cameraSettings[calibration.camera.index] ?? null}
+					hasCrop={cameraHasCrop(document, tl.cameraSettings, calibration.camera.index)}
+					onApply={(patch) => void setCameraSettingsQueued(calibration.camera.index, patch)}
+					onClose={() => setCalibration(null)}
+				/>
+			) : null}
 			<UnsavedChangesModal
 				open={unsavedPrompt !== null}
 				onClose={() => {
diff --git a/src/components/ai-edition/Preview.tsx b/src/components/ai-edition/Preview.tsx
index f4ad0a5c5..23f032c00 100644
--- a/src/components/ai-edition/Preview.tsx
+++ b/src/components/ai-edition/Preview.tsx
@@ -1,5 +1,9 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
-import type { CameraFullscreenRegion, ZoomFocus } from "@/components/video-editor/types";
+import type {
+	CameraFullscreenRegion,
+	NormalizedRect,
+	ZoomFocus,
+} from "@/components/video-editor/types";
 import { useScopedT } from "@/contexts/I18nContext";
 import type {
 	AxcutAnnotationRegion,
@@ -11,6 +15,7 @@ import type {
 } from "@/lib/ai-edition/schema";
 import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
 import type { SpeedRegion } from "@/lib/ai-edition/timeline/speed";
+import type { AnchoredCameraLayoutRegion } from "@/lib/cameraLayouts";
 import { EditorEmptyState } from "./EditorEmptyState";
 import styles from "./NewEditorShell.module.css";
 import { PreviewCanvas } from "./PreviewCanvas";
@@ -43,6 +48,10 @@ interface PreviewProps {
 	selectedZoomRegionId?: string | null;
 	onZoomFocusChange?: (id: string, focus: ZoomFocus) => void;
 	onZoomFocusCommit?: () => void;
+	cameraLayoutRegions?: AnchoredCameraLayoutRegion[];
+	selectedLayoutRegionId?: string | null;
+	onLayoutSlotRectLive?: (id: string, slotIndex: number, rect: NormalizedRect) => void;
+	onLayoutSlotRectCommit?: () => void;
 	annotationRegions?: AxcutAnnotationRegion[];
 	selectedAnnotationId?: string | null;
 	onSelectAnnotation?: (id: string) => void;
@@ -78,6 +87,10 @@ export function Preview({
 	selectedZoomRegionId,
 	onZoomFocusChange,
 	onZoomFocusCommit,
+	cameraLayoutRegions,
+	selectedLayoutRegionId,
+	onLayoutSlotRectLive,
+	onLayoutSlotRectCommit,
 	annotationRegions,
 	selectedAnnotationId,
 	onSelectAnnotation,
@@ -221,6 +234,10 @@ export function Preview({
 						selectedZoomRegionId={selectedZoomRegionId}
 						onZoomFocusChange={onZoomFocusChange}
 						onZoomFocusCommit={onZoomFocusCommit}
+						cameraLayoutRegions={cameraLayoutRegions}
+						selectedLayoutRegionId={selectedLayoutRegionId}
+						onLayoutSlotRectLive={onLayoutSlotRectLive}
+						onLayoutSlotRectCommit={onLayoutSlotRectCommit}
 						annotationRegions={annotationRegions}
 						selectedAnnotationId={selectedAnnotationId}
 						onSelectAnnotation={onSelectAnnotation}
diff --git a/src/components/ai-edition/PreviewCanvas.layoutPlaces.test.tsx b/src/components/ai-edition/PreviewCanvas.layoutPlaces.test.tsx
new file mode 100644
index 000000000..3baa78fa3
--- /dev/null
+++ b/src/components/ai-edition/PreviewCanvas.layoutPlaces.test.tsx
@@ -0,0 +1,177 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import type { ComponentProps } from "react";
+import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import type { AxcutAsset, AxcutClip } from "@/lib/ai-edition/schema";
+import { createEmptyDocument } from "@/lib/ai-edition/schema";
+import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
+import type { AnchoredCameraLayoutRegion } from "@/lib/cameraLayouts";
+import { PreviewCanvas } from "./PreviewCanvas";
+
+vi.mock("@/native/client", () => ({ nativeBridgeClient: { aiEdition: {} } }));
+vi.mock("@/contexts/I18nContext", () => ({
+	useScopedT: (scope: string) => (key: string) => `${scope}.${key}`,
+}));
+// The pixel and media layers are not under test: only the DOM hitboxes are.
+vi.mock("./NativeCompositorOverlay", () => ({ NativeCompositorOverlay: () => null }));
+vi.mock("./VirtualPreview", () => ({ VirtualPreview: () => null }));
+vi.mock("./WebcamOverlay", () => ({ WebcamOverlay: () => null }));
+vi.mock("./ZoomFocusOverlay", () => ({ ZoomFocusOverlay: () => null }));
+vi.mock("./AnnotationLayer", () => ({ AnnotationLayer: () => null }));
+
+const track = (path: string) => ({
+	sourcePath: path,
+	startMs: 0,
+	offsetMs: 0,
+	visible: true,
+	width: 1920,
+	height: 1080,
+});
+
+const asset = {
+	id: "a1",
+	kind: "video",
+	label: "a",
+	originalPath: "/screen.mp4",
+	cameraTrack: track("/c1.mp4"),
+	additionalCameraTracks: [{ ...track("/c2.mp4"), label: "" }],
+} as unknown as AxcutAsset;
+
+const clip = {
+	id: "c1",
+	assetId: "a1",
+	sourceStartSec: 0,
+	sourceEndSec: 10,
+	timelineStartSec: 0,
+	timelineEndSec: 10,
+	wordRefs: [],
+	origin: "user",
+	reason: "",
+} as AxcutClip;
+
+const region = (
+	template: AnchoredCameraLayoutRegion["template"],
+	cameras: number[],
+): AnchoredCameraLayoutRegion => ({
+	id: "l1",
+	startMs: 0,
+	endMs: 10_000,
+	template,
+	slots: cameras.map((camera) => ({ camera })),
+	clipId: "c1",
+	assetId: "a1",
+	sourceStartSec: 0,
+	sourceEndSec: 10,
+});
+
+type Props = ComponentProps<typeof PreviewCanvas>;
+
+function renderCanvas(over: Partial<Props>) {
+	const document = createEmptyDocument({ projectId: "p", title: "t" });
+	useProjectStore.setState({
+		projectId: "p",
+		document: { ...document, assets: [asset] },
+	});
+	const props: Props = {
+		videoSources: [],
+		clips: [clip],
+		seekTarget: null,
+		onTimeChange: vi.fn(),
+		onSeek: vi.fn(),
+		onLoadedMetadata: vi.fn(),
+		onVideoElement: vi.fn(),
+		currentTimeSec: 5,
+		onLayoutSlotRectLive: vi.fn(),
+		onLayoutSlotRectCommit: vi.fn(),
+		...over,
+	};
+	render(
+		<div>
+			<PreviewCanvas {...props} />
+		</div>,
+	);
+	return props;
+}
+
+beforeAll(() => {
+	// jsdom lays nothing out: give every element a 1000×500 box and a pointer-capture API.
+	vi.spyOn(HTMLElement.prototype, "getBoundingClientRect").mockReturnValue({
+		left: 0,
+		top: 0,
+		width: 1000,
+		height: 500,
+		right: 1000,
+		bottom: 500,
+		x: 0,
+		y: 0,
+		toJSON: () => ({}),
+	});
+	HTMLElement.prototype.setPointerCapture = vi.fn();
+	HTMLElement.prototype.releasePointerCapture = vi.fn();
+});
+
+afterEach(() => {
+	cleanup();
+	useProjectStore.getState().clear();
+});
+
+describe("PreviewCanvas layout places", () => {
+	it("a selected layout section shows a handle per pip place", () => {
+		const regions = [region("screen-pip", [0, 1])];
+		renderCanvas({ cameraLayoutRegions: regions, selectedLayoutRegionId: "l1" });
+		expect(screen.getAllByTestId("layout-place")).toHaveLength(2);
+		expect(screen.getAllByTestId("layout-place-handle")).toHaveLength(2);
+	});
+
+	it("gives a frame-filling place no handle", () => {
+		const regions = [region("camera-full-pip", [1, 0])];
+		renderCanvas({ cameraLayoutRegions: regions, selectedLayoutRegionId: "l1" });
+		expect(screen.getAllByTestId("layout-place-handle")).toHaveLength(1);
+	});
+
+	it("shows nothing when the section is not selected or the playhead is outside it", () => {
+		const regions = [region("screen-pip", [0, 1])];
+		renderCanvas({ cameraLayoutRegions: regions, selectedLayoutRegionId: null });
+		expect(screen.queryByTestId("layout-place")).toBeNull();
+		cleanup();
+		renderCanvas({
+			cameraLayoutRegions: [{ ...regions[0], endMs: 2000 }],
+			selectedLayoutRegionId: "l1",
+		});
+		expect(screen.queryByTestId("layout-place")).toBeNull();
+	});
+
+	it("moves a place live and commits once on release", () => {
+		const regions = [region("camera-full-pip", [1, 0])];
+		const onLive = vi.fn<NonNullable<Props["onLayoutSlotRectLive"]>>();
+		const props = renderCanvas({
+			cameraLayoutRegions: regions,
+			selectedLayoutRegionId: "l1",
+			onLayoutSlotRectLive: onLive,
+		});
+		const place = screen.getByTestId("layout-place");
+		fireEvent.pointerDown(place, { pointerId: 1, clientX: 500, clientY: 250 });
+		fireEvent.pointerMove(place, { pointerId: 1, clientX: 400, clientY: 200 });
+		fireEvent.pointerMove(place, { pointerId: 1, clientX: 300, clientY: 150 });
+		fireEvent.pointerUp(place, { pointerId: 1 });
+		expect(onLive).toHaveBeenCalledTimes(2);
+		const [[id, slotIndex, first], [, , last]] = onLive.mock.calls;
+		// Slot 1 is the PiP of camera-full-pip (slot 0 fills the frame).
+		expect([id, slotIndex]).toEqual(["l1", 1]);
+		// Both moves are measured from the grab: the second one went twice as far.
+		expect(first.x - last.x).toBeCloseTo(0.1);
+		expect(first.y - last.y).toBeCloseTo(0.1);
+		expect(last.width).toBe(first.width);
+		expect(props.onLayoutSlotRectCommit).toHaveBeenCalledTimes(1);
+	});
+
+	it("leaves no undo step for a click without a move", () => {
+		const regions = [region("screen-pip", [0])];
+		const props = renderCanvas({ cameraLayoutRegions: regions, selectedLayoutRegionId: "l1" });
+		const place = screen.getByTestId("layout-place");
+		fireEvent.pointerDown(place, { pointerId: 1, clientX: 500, clientY: 250 });
+		fireEvent.pointerUp(place, { pointerId: 1 });
+		expect(props.onLayoutSlotRectCommit).not.toHaveBeenCalled();
+	});
+});
diff --git a/src/components/ai-edition/PreviewCanvas.tsx b/src/components/ai-edition/PreviewCanvas.tsx
index c817fde3c..8ed2c57b0 100644
--- a/src/components/ai-edition/PreviewCanvas.tsx
+++ b/src/components/ai-edition/PreviewCanvas.tsx
@@ -28,6 +28,7 @@ import {
 	type CameraFullscreenRegion,
 	type CropRegion,
 	DEFAULT_CROP_REGION,
+	type NormalizedRect,
 	type WebcamLayoutPreset,
 	type WebcamMaskShape,
 	type ZoomFocus,
@@ -47,9 +48,23 @@ import type {
 } from "@/lib/ai-edition/schema";
 import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
 import { useEditorSettings } from "@/lib/ai-edition/store/useEditorSettings";
-import { resolveActiveCameraTrack } from "@/lib/ai-edition/timeline/camera";
+import {
+	assetAdditionalCameraSources,
+	assetCameraSource,
+	resolveActiveCameraTrack,
+} from "@/lib/ai-edition/timeline/camera";
+import {
+	inwardCorner,
+	moveSlotRect,
+	type PipPlace,
+	pipPlacesOf,
+	resizeSlotRect,
+	type SlotCorner,
+} from "@/lib/ai-edition/timeline/layoutSlotDrag";
 import type { SpeedRegion } from "@/lib/ai-edition/timeline/speed";
+import { resolvePillIds } from "@/lib/ai-edition/timeline/timelineMap";
 import { locateVirtualPosition } from "@/lib/ai-edition/timeline/virtual-preview";
+import { type AnchoredCameraLayoutRegion, normalizeCameraSettings } from "@/lib/cameraLayouts";
 import {
 	computeCameraFullscreenRect,
 	computeCompositeLayout,
@@ -61,7 +76,12 @@ import { webcamAnchorAt } from "@/lib/projectDefaults";
 import { wallpaperStyle } from "@/lib/wallpaper";
 import { getCssClipPath } from "@/lib/webcamMaskShapes";
 import { computeCameraFullscreenProgress } from "@/lib/zoomMath/cameraFullscreenUtils";
-import { webcamBoxSourceSize } from "@/native/sceneDescription";
+import {
+	camera0PerspectiveOf,
+	cameraLayoutContextOf,
+	clipPipLayoutOf,
+	webcamBoxSourceSize,
+} from "@/native/sceneDescription";
 import {
 	getWebcamNativeSize,
 	getWebcamNativeSizeRevision,
@@ -92,6 +112,13 @@ interface PreviewCanvasProps {
 	selectedZoomRegionId?: string | null;
 	onZoomFocusChange?: (id: string, focus: ZoomFocus) => void;
 	onZoomFocusCommit?: () => void;
+	/** Layout sections; the selected one's PiP places get move/resize hitboxes. */
+	cameraLayoutRegions?: AnchoredCameraLayoutRegion[];
+	selectedLayoutRegionId?: string | null;
+	/** Live edit of a place's rect during a gesture (no undo step). */
+	onLayoutSlotRectLive?: (id: string, slotIndex: number, rect: NormalizedRect) => void;
+	/** End of the gesture: one undo step. */
+	onLayoutSlotRectCommit?: () => void;
 	annotationRegions?: AxcutAnnotationRegion[];
 	selectedAnnotationId?: string | null;
 	onSelectAnnotation?: (id: string) => void;
@@ -243,6 +270,8 @@ export function PreviewCanvas(props: PreviewCanvasProps) {
 		getWebcamNativeSizeRevision,
 		() => 0,
 	);
+	// A perspective on camera 1 gives the box its corrected ratio, as in the scene.
+	const camera0Perspective = useMemo(() => camera0PerspectiveOf(document), [document]);
 	// biome-ignore lint/correctness/useExhaustiveDependencies: the revision re-reads the probed-size cache
 	const webcamSourceSize = useMemo(
 		() =>
@@ -250,8 +279,9 @@ export function PreviewCanvas(props: PreviewCanvasProps) {
 				activeCameraTrack,
 				activeCameraTrack?.sourcePath ? getWebcamNativeSize(activeCameraTrack.sourcePath) : null,
 				settings.webcamCropRegion,
+				camera0Perspective,
 			),
-		[activeCameraTrack, settings.webcamCropRegion, webcamSizeRevision],
+		[activeCameraTrack, settings.webcamCropRegion, camera0Perspective, webcamSizeRevision],
 	);
 
 	const formatFill = useMemo(() => (document ? isFormatFillActive(document) : false), [document]);
@@ -351,6 +381,60 @@ export function PreviewCanvas(props: PreviewCanvasProps) {
 	// camera-less clip, so this is belt-and-braces rather than the only guard.
 	const showWebcamSlot = Boolean(layout?.webcamRect && activeClipHasCamera);
 	const [isPlaying, setIsPlaying] = useState(false);
+
+	// The selected layout section's row under the playhead: one pill can span several clip-
+	// anchored rows, and the one under the playhead names the asset whose cameras are drawn.
+	const layoutRow = useMemo(() => {
+		const id = props.selectedLayoutRegionId;
+		const regions = props.cameraLayoutRegions;
+		if (!id || !regions) return null;
+		const pill = new Set(resolvePillIds(regions, id));
+		const nowMs = props.currentTimeSec * 1000;
+		return regions.find((r) => pill.has(r.id) && nowMs >= r.startMs && nowMs < r.endMs) ?? null;
+	}, [props.selectedLayoutRegionId, props.cameraLayoutRegions, props.currentTimeSec]);
+	// Its PiP places, through the context the scene builds, so each hitbox sits on the window
+	// the compositor draws. Frame-filling places get none.
+	// biome-ignore lint/correctness/useExhaustiveDependencies: the revision re-reads the probed-size cache
+	const layoutPlaces = useMemo((): PipPlace[] => {
+		if (!layoutRow || frameSize.width <= 0 || frameSize.height <= 0) return [];
+		const asset = assets.find((a) => a.id === (layoutRow.assetId ?? activeClip?.assetId));
+		if (!asset) return [];
+		const sources = [assetCameraSource(asset), ...assetAdditionalCameraSources(asset)];
+		const legacy = document?.legacyEditor as Record<string, unknown> | null | undefined;
+		const camera0Path = asset.cameraTrack?.sourcePath;
+		const maskShape = settings.webcamMaskShape as WebcamMaskShape;
+		const ctx = cameraLayoutContextOf({
+			frame: frameSize,
+			asset,
+			cameraSettings: normalizeCameraSettings(legacy?.cameraSettings),
+			webcamCropRegion: settings.webcamCropRegion,
+			probedCamera0Size: camera0Path ? getWebcamNativeSize(camera0Path) : null,
+			clipLayout: clipPipLayoutOf(layout, frameSize, maskShape),
+			webcamMaskShape: maskShape,
+			webcamRoundness: settings.webcamRoundness,
+			pipPreset:
+				resolveWebcamLayoutPreset(
+					settings.webcamLayoutPreset as WebcamLayoutPreset,
+					activeClipHasCamera,
+				) === "picture-in-picture",
+		});
+		return pipPlacesOf(layoutRow, ctx).filter((p) => (sources[p.camera]?.path ?? "") !== "");
+	}, [
+		layoutRow,
+		frameSize,
+		assets,
+		activeClip,
+		document,
+		layout,
+		activeClipHasCamera,
+		settings.webcamCropRegion,
+		settings.webcamMaskShape,
+		settings.webcamRoundness,
+		settings.webcamLayoutPreset,
+		webcamSizeRevision,
+	]);
+	const editsLayoutPlaces =
+		layoutPlaces.length > 0 && !isPlaying && props.onLayoutSlotRectLive !== undefined;
 	const handleVideoElement = useMemo(() => props.onVideoElement, [props.onVideoElement]);
 	// L'élément `<video>` lui-même n'est plus retenu : il ne servait qu'à échantillonner des pixels
 	// pour la mosaïque dessinée en DOM, que le compositeur natif rend désormais.
@@ -424,7 +508,55 @@ export function PreviewCanvas(props: PreviewCanvasProps) {
 		slot.addEventListener("pointercancel", handleUp);
 	};
 
-	const isPipGrab = settings.webcamLayoutPreset === "picture-in-picture";
+	// Moving (the place itself) or resizing (its corner handle) a layout section's PiP place:
+	// pointer capture on the grabbed element, live rects while it moves, one commit on release.
+	const handleLayoutPlacePointerDown = (
+		event: ReactPointerEvent<HTMLDivElement>,
+		place: PipPlace,
+		mode: "move" | SlotCorner,
+	) => {
+		const onLive = props.onLayoutSlotRectLive;
+		if (!layoutRow || !onLive || isPlaying) return;
+		const frameRect = frameRef.current?.getBoundingClientRect();
+		if (!frameRect || frameRect.width <= 0 || frameRect.height <= 0) return;
+		event.preventDefault();
+		event.stopPropagation();
+		const target = event.currentTarget;
+		target.setPointerCapture(event.pointerId);
+		const sectionId = layoutRow.id;
+		const startX = event.clientX;
+		const startY = event.clientY;
+		const frame = { width: frameRect.width, height: frameRect.height };
+		let moved = false;
+		const handleMove = (e: PointerEvent) => {
+			const dx = (e.clientX - startX) / frame.width;
+			const dy = (e.clientY - startY) / frame.height;
+			const rect =
+				mode === "move"
+					? moveSlotRect(place.rect, dx, dy)
+					: resizeSlotRect(place.rect, mode, dx, dy, place.aspect, frame);
+			moved = true;
+			onLive(sectionId, place.slotIndex, rect);
+		};
+		const handleUp = () => {
+			target.removeEventListener("pointermove", handleMove);
+			target.removeEventListener("pointerup", handleUp);
+			target.removeEventListener("pointercancel", handleUp);
+			try {
+				target.releasePointerCapture(event.pointerId);
+			} catch {
+				// pointer already released
+			}
+			// A click without a move changes nothing and leaves no undo step.
+			if (moved) props.onLayoutSlotRectCommit?.();
+		};
+		target.addEventListener("pointermove", handleMove);
+		target.addEventListener("pointerup", handleUp);
+		target.addEventListener("pointercancel", handleUp);
+	};
+
+	// Inside a selected layout section the places take the pointer, not camera 1's anchor drag.
+	const isPipGrab = settings.webcamLayoutPreset === "picture-in-picture" && !editsLayoutPlaces;
 
 	const selectedZoomRegion = props.selectedZoomRegionId
 		? (props.zoomRegions?.find((z) => z.id === props.selectedZoomRegionId) ?? null)
@@ -492,6 +624,29 @@ export function PreviewCanvas(props: PreviewCanvasProps) {
 					<WebcamOverlay clips={props.clips} currentTimeSec={props.currentTimeSec} />
 				</div>
 			) : null}
+			{editsLayoutPlaces
+				? layoutPlaces.map((place) => {
+						const corner = inwardCorner(place.rect);
+						return (
+							<div
+								key={place.slotIndex}
+								className={styles.layoutPlace}
+								style={layoutPlaceStyle(place.rect)}
+								data-testid="layout-place"
+								aria-label={te("preview.layoutPlace")}
+								onPointerDown={(e) => handleLayoutPlacePointerDown(e, place, "move")}
+							>
+								<div
+									className={styles.layoutPlaceHandle}
+									style={layoutHandleStyle(corner)}
+									data-testid="layout-place-handle"
+									aria-label={te("preview.layoutPlaceResize")}
+									onPointerDown={(e) => handleLayoutPlacePointerDown(e, place, corner)}
+								/>
+							</div>
+						);
+					})
+				: null}
 			{/* Last, so a selected annotation over the camera takes the pointer before the
 			    camera's drag hitbox does. It spans the frame: text, images and arrows move
 			    anywhere in it, over the padding too. */}
@@ -583,3 +738,22 @@ function buildWebcamStyle(
 	};
 	return clipPath ? { ...base, clipPath } : base;
 }
+
+// A layout place's hitbox: its rect in percent of the frame. No clip-path, unlike the webcam
+// slot: the resize handle sits on the rect's corner, outside a circle's disc.
+function layoutPlaceStyle(rect: NormalizedRect): React.CSSProperties {
+	return {
+		left: `${rect.x * 100}%`,
+		top: `${rect.y * 100}%`,
+		width: `${rect.width * 100}%`,
+		height: `${rect.height * 100}%`,
+	};
+}
+
+function layoutHandleStyle(corner: SlotCorner): React.CSSProperties {
+	return {
+		left: corner === "nw" || corner === "sw" ? 0 : "100%",
+		top: corner === "nw" || corner === "ne" ? 0 : "100%",
+		cursor: corner === "nw" || corner === "se" ? "nwse-resize" : "nesw-resize",
+	};
+}
diff --git a/src/components/ai-edition/RightPanes.tsx b/src/components/ai-edition/RightPanes.tsx
index fe1f00bf6..616529940 100644
--- a/src/components/ai-edition/RightPanes.tsx
+++ b/src/components/ai-edition/RightPanes.tsx
@@ -149,6 +149,7 @@ import { ROUNDNESS_SLIDER_MAX_PX } from "@/native/paramUnits";
 import { wallpaperAcceptsMotion } from "@/native/sceneDescription";
 import { ASPECT_RATIO_PRESETS, type AspectRatio } from "@/utils/aspectRatioUtils";
 import { useCanSegmentCamera } from "../../native/hooks/useSegmentationSupport";
+import { CamerasSection, type CamerasSectionProps } from "./CamerasSection";
 import { CaptionsPane } from "./CaptionsPane";
 import { ColorField } from "./ColorField";
 import { insertionsEnabled } from "./insertionsEnabled";
@@ -2779,7 +2780,12 @@ const CAMERA_BACKGROUND_MODES: Array<{
 	},
 ];
 
-export function LayoutPane() {
+export function LayoutPane({
+	cameras,
+}: {
+	/** The per-camera list; absent where the pane has no timeline store at hand. */
+	cameras?: Pick<CamerasSectionProps, "cameraSettings" | "setCameraSettings" | "onOpenCalibration">;
+} = {}) {
 	const canSegmentCamera = useCanSegmentCamera();
 	const ts = useScopedT("settings");
 	const { settings, set, setLive, commit, hasDocument } = useEditorSettings();
@@ -3114,6 +3120,7 @@ export function LayoutPane() {
 				onFrameLive={setCropFrame}
 				onCommit={() => void commit()}
 			/>
+			{cameras ? <CamerasSection document={document} {...cameras} /> : null}
 		</Pane>
 	);
 }
diff --git a/src/components/ai-edition/v4/FloatingInspector.test.tsx b/src/components/ai-edition/v4/FloatingInspector.test.tsx
index 275b93cbc..5e85d7283 100644
--- a/src/components/ai-edition/v4/FloatingInspector.test.tsx
+++ b/src/components/ai-edition/v4/FloatingInspector.test.tsx
@@ -38,7 +38,16 @@ vi.mock("../RightPanes", async (importOriginal) => ({
 		</div>
 	),
 	CursorPane: () => <div data-testid="cursor-pane">CursorPane</div>,
-	LayoutPane: () => <div data-testid="layout-pane">LayoutPane</div>,
+	// Hands its `cameras` writer out, so a test can tell which one the inspector passed down.
+	LayoutPane: ({ cameras }: { cameras?: { setCameraSettings?: unknown } }) => (
+		<button
+			type="button"
+			data-testid="layout-pane"
+			onClick={() => (cameras?.setCameraSettings as (i: number, p: null) => void)?.(1, null)}
+		>
+			LayoutPane
+		</button>
+	),
 	SliderCell: () => <div data-testid="slider-cell">SliderCell</div>,
 	TranscriptPane: () => <div data-testid="transcript-pane">TranscriptPane</div>,
 	VideoEffectsPane: () => <div data-testid="effects-pane">VideoEffectsPane</div>,
@@ -84,6 +93,7 @@ describe("FloatingInspector", () => {
 		onToggleOpen: vi.fn(),
 		clips: [],
 		onEditClip: vi.fn(),
+		setCameraSettings: vi.fn(),
 		transcriptProps: {} as unknown as React.ComponentProps<
 			typeof FloatingInspector
 		>["transcriptProps"],
@@ -95,6 +105,18 @@ describe("FloatingInspector", () => {
 		} as unknown as React.ComponentProps<typeof FloatingInspector>["tl"],
 	};
 
+	it("the layout pane writes camera settings through the writer it was given", () => {
+		const setCameraSettings = vi.fn();
+		const tl = {
+			...defaultProps.tl,
+			setCameraSettings: vi.fn(),
+		} as unknown as React.ComponentProps<typeof FloatingInspector>["tl"];
+		render(<FloatingInspector {...defaultProps} tl={tl} setCameraSettings={setCameraSettings} />);
+		fireEvent.click(screen.getByTestId("layout-pane"));
+		expect(setCameraSettings).toHaveBeenCalledWith(1, null);
+		expect(tl.setCameraSettings).not.toHaveBeenCalled();
+	});
+
 	it("renders layout facet button on rail with camera icon and settings.layout.title", () => {
 		render(<FloatingInspector {...defaultProps} />);
 		const layoutBtn = screen.getByRole("button", { name: "settings.layout.title" });
@@ -536,6 +558,31 @@ describe("FloatingInspector", () => {
 			return { tl, updateCameraFullscreenOrientation, updateCameraFullscreenDeskLabel };
 		};
 
+		it("the full camera pane offers the template choice", async () => {
+			const { tl } = camTl({});
+			const setLayoutTemplate = vi.fn(async () => ({ kind: "cameraLayout" as const, id: "L9" }));
+			const selectRegion = vi.fn();
+			Object.assign(tl, { setLayoutTemplate, selectRegion });
+			render(<FloatingInspector {...defaultProps} tl={tl} />);
+			expect(
+				screen.getByRole("group", { name: "settings.cameraLayout.template" }),
+			).toBeInTheDocument();
+			const current = screen.getByRole("button", { name: /timeline.labels.layoutCameraFull$/ });
+			expect(current).toHaveAttribute("aria-pressed", "true");
+			// Only one camera is known here, so the two-camera templates are off.
+			expect(
+				screen.getByRole("button", { name: /timeline.labels.layoutSideBySide/ }),
+			).toBeDisabled();
+			fireEvent.click(screen.getByRole("button", { name: /timeline.labels.layoutScreenPip/ }));
+			expect(setLayoutTemplate).toHaveBeenCalledWith(
+				{ kind: "cameraFullscreen", id: "cf" },
+				"screen-pip",
+				[],
+			);
+			// The section moved to the layout list: the selection follows it.
+			await waitFor(() => expect(selectRegion).toHaveBeenCalledWith("cameraLayout", "L9"));
+		});
+
 		it("desk view sets both fields in one call", () => {
 			const { tl, updateCameraFullscreenOrientation } = camTl({});
 			render(<FloatingInspector {...defaultProps} tl={tl} />);
diff --git a/src/components/ai-edition/v4/FloatingInspector.tsx b/src/components/ai-edition/v4/FloatingInspector.tsx
index db594f517..f77bfb0d4 100644
--- a/src/components/ai-edition/v4/FloatingInspector.tsx
+++ b/src/components/ai-edition/v4/FloatingInspector.tsx
@@ -23,7 +23,6 @@ import {
 	Trash2,
 	Type,
 	Undo2,
-	X,
 	ZoomIn,
 } from "lucide-react";
 import type { ComponentProps } from "react";
@@ -59,6 +58,7 @@ import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
 import { rafCoalesce } from "@/lib/ai-edition/store/rafCoalesce";
 import { useEditorSettings } from "@/lib/ai-edition/store/useEditorSettings";
 import type { useTimeline } from "@/lib/ai-edition/store/useTimeline";
+import { camerasOfSection } from "@/lib/ai-edition/timeline/cameraList";
 import { formatSeconds } from "@/lib/ai-edition/timeline/format";
 import { coalescedTrimGroups } from "@/lib/ai-edition/timeline/trim-mapping";
 import {
@@ -69,8 +69,10 @@ import {
 	normalizeCameraRotation,
 	showsDeskLabel,
 } from "@/lib/cameraOrientation";
+import { isWebcamBlockLayout } from "@/lib/compositeLayout";
 import { clampToBound } from "@/lib/projectDefaults";
 import { annotationFootageRect, zoomScaleLimit } from "@/native/sceneDescription";
+import type { CamerasSectionProps } from "../CamerasSection";
 import { ColorField } from "../ColorField";
 import shell from "../NewEditorShell.module.css";
 import {
@@ -87,6 +89,8 @@ import {
 import { useHasRecordedCursor } from "../recordedCursorTypes";
 import { TextColorField } from "../TextColorField";
 import styles from "./EditorShellV4.module.css";
+import { LayoutSectionPane, LayoutTemplateChoice } from "./LayoutSectionPane";
+import { PANE_BODY_STYLE, PANE_BUTTON, paneHeader, paneRow, paneStack } from "./paneParts";
 
 type TimelineApi = ReturnType<typeof useTimeline>;
 
@@ -130,6 +134,10 @@ interface FloatingInspectorProps {
 	 * selected. Clicking elsewhere on the timeline clears the selection
 	 * (see V4Timeline's empty-area click handler) which closes this pane. */
 	tl: TimelineApi;
+	/** Opens the camera calibration dialog (the shell holds its one instance). */
+	onOpenCalibration?: CamerasSectionProps["onOpenCalibration"];
+	/** Per-camera settings writer; the shell's queued one, so it cannot race other writes. */
+	setCameraSettings: CamerasSectionProps["setCameraSettings"];
 }
 
 export function FloatingInspector({
@@ -141,6 +149,8 @@ export function FloatingInspector({
 	onEditClip,
 	transcriptProps,
 	tl,
+	onOpenCalibration,
+	setCameraSettings,
 }: FloatingInspectorProps) {
 	const ts = useScopedT("settings");
 	const te = useScopedT("editor");
@@ -185,7 +195,14 @@ export function FloatingInspector({
 					) : audioTrackSelected ? (
 						<AudioTrackPane tl={tl} onClose={() => tl.clearSelection()} />
 					) : (
-						<FacetBody facet={facet} onCollapse={onToggleOpen} transcriptProps={transcriptProps} />
+						<FacetBody
+							facet={facet}
+							onCollapse={onToggleOpen}
+							transcriptProps={transcriptProps}
+							tl={tl}
+							onOpenCalibration={onOpenCalibration}
+							setCameraSettings={setCameraSettings}
+						/>
 					)}
 				</div>
 			) : null}
@@ -307,80 +324,6 @@ export function FloatingInspector({
 	);
 }
 
-function paneHeader(icon: React.ReactNode, title: string, onClose: () => void, closeLabel: string) {
-	return (
-		<header
-			style={{
-				display: "flex",
-				alignItems: "center",
-				gap: 8,
-				padding: "14px 16px 12px",
-				borderBottom: "1px solid var(--border-soft)",
-				// Le corps défile sous l'en-tête : sans ça, l'en-tête se comprime avec lui.
-				flexShrink: 0,
-			}}
-		>
-			<span style={{ display: "grid", placeItems: "center", color: "var(--muted)" }}>{icon}</span>
-			<h2
-				style={{
-					margin: 0,
-					flex: 1,
-					fontSize: 14,
-					fontWeight: 600,
-					color: "var(--fg-emphasis)",
-					letterSpacing: "-0.01em",
-				}}
-			>
-				{title}
-			</h2>
-			<button
-				type="button"
-				className={styles.iconBtn}
-				title={closeLabel}
-				aria-label={closeLabel}
-				onClick={onClose}
-				style={{
-					width: 30,
-					height: 30,
-				}}
-			>
-				<X size={16} />
-			</button>
-		</header>
-	);
-}
-
-function paneRow(label: string, control: React.ReactNode) {
-	return (
-		<div
-			style={{
-				display: "flex",
-				alignItems: "center",
-				justifyContent: "space-between",
-				gap: 10,
-			}}
-		>
-			<span style={{ fontSize: 13, color: "var(--fg-2)", fontWeight: 500 }}>{label}</span>
-			{control}
-		</div>
-	);
-}
-
-/** Un libellé au-dessus de son contrôle, pour ceux qui prennent toute la largeur du panneau
- *  (une `ChoiceRow`) : à côté d'un libellé, ils n'auraient plus la place de montrer leurs choix.
- *  `value` nomme le choix courant quand les boutons ne font que le dessiner. */
-function paneStack(label: string, control: React.ReactNode, value?: string) {
-	return (
-		<div style={{ display: "flex", flexDirection: "column", gap: 6 }}>
-			<span style={{ fontSize: 13, color: "var(--fg-2)", fontWeight: 500 }}>
-				{label}
-				{value ? <span className={shell.sectionLabelValue}>{value}</span> : null}
-			</span>
-			{control}
-		</div>
-	);
-}
-
 /** What each camera does to the screen (viewBox 0 0 32 22, as the camera layout tiles). A fixed
  *  angle is the outline of its pose: `ROTATION_3D_PRESETS` projected with the shipped
  *  perspective and centred. The moving camera leaves the screen flat and circles it. */
@@ -812,23 +755,7 @@ function SelectionPane({ tl, onClose }: { tl: TimelineApi; onClose: () => void }
 		onClose();
 	};
 
-	// Le panneau découpe son contenu (coins arrondis + flou), donc un corps sans ascenseur perd
-	// silencieusement ce qui dépasse — c'est ce qui arrivait au pane d'annotation, le plus haut de
-	// tous, dès qu'on réduisait la fenêtre. L'en-tête reste fixe, le corps défile, comme les
-	// panneaux de facette (cf. `.paneBody` de NewEditorShell).
-	const bodyStyle: React.CSSProperties = {
-		padding: "16px",
-		display: "flex",
-		flexDirection: "column",
-		gap: 16,
-		flex: "1 1 auto",
-		minHeight: 0,
-		overflowY: "auto",
-		overflowX: "hidden",
-		overscrollBehavior: "contain",
-		scrollbarWidth: "thin",
-		scrollbarColor: "var(--border) transparent",
-	};
+	const bodyStyle = PANE_BODY_STYLE;
 
 	if (selection.kind === "zoom") {
 		const region = tl.zoomRegions.find((z) => z.id === selection.id);
@@ -1274,12 +1201,34 @@ function SelectionPane({ tl, onClose }: { tl: TimelineApi; onClose: () => void }
 		);
 	}
 
+	// The cameras of the asset a camera section is anchored to (its row's `assetId`).
+	const camerasUnder = (region: { assetId?: string; startMs: number; endMs: number }) =>
+		doc ? camerasOfSection(doc, region, ts) : [];
+	const blockPreset = isWebcamBlockLayout(settings.webcamLayoutPreset);
+
+	if (selection.kind === "cameraLayout") {
+		const region = tl.cameraLayoutRegions.find((r) => r.id === selection.id);
+		if (!region) return null;
+		return (
+			<LayoutSectionPane
+				tl={tl}
+				region={region}
+				cameras={camerasUnder(region)}
+				blockPreset={blockPreset}
+				onClose={onClose}
+			/>
+		);
+	}
+
 	if (selection.kind === "cameraFullscreen") {
 		const region = tl.cameraFullscreenRegions.find((c) => c.id === selection.id);
 		if (!region) return null;
 		const rotation = normalizeCameraRotation(region.rotation);
 		const mirror = normalizeCameraMirror(region.mirror);
 		const desk = isDeskView(region);
+		const available = camerasUnder(region)
+			.filter((c) => c.available)
+			.map((c) => c.index);
 		const setOrientation = (next: { rotation: CameraRotation; mirror: CameraMirrorMode }) =>
 			void tl.updateCameraFullscreenOrientation(region.id, next);
 		return (
@@ -1291,6 +1240,19 @@ function SelectionPane({ tl, onClose }: { tl: TimelineApi; onClose: () => void }
 					tc("actions.close"),
 				)}
 				<div style={bodyStyle}>
+					<LayoutTemplateChoice
+						current="camera-full"
+						cameraCount={new Set([0, ...available]).size}
+						blockPreset={blockPreset}
+						onPick={(template) =>
+							void tl
+								.setLayoutTemplate({ kind: "cameraFullscreen", id: region.id }, template, available)
+								.then((next) => {
+									if (next.kind !== "cameraFullscreen" || next.id !== region.id)
+										tl.selectRegion(next.kind, next.id);
+								})
+						}
+					/>
 					{/* One click for the common case: a camera tilted onto the desk is upside down
 					    and must not be mirrored, or the papers' text reads back to front. */}
 					<button
@@ -1380,18 +1342,20 @@ function SelectionPane({ tl, onClose }: { tl: TimelineApi; onClose: () => void }
 	);
 }
 
-/** Every action of the selection pane, delete included: the red icon says it destroys; a red
- *  slab outshouted every setting above it. */
-const PANE_BUTTON = `${shell.btn} ${shell.btnSecondary}`;
-
 function FacetBody({
 	facet,
 	onCollapse,
 	transcriptProps,
+	tl,
+	onOpenCalibration,
+	setCameraSettings,
 }: {
 	facet: Facet;
 	onCollapse: () => void;
 	transcriptProps: TranscriptProps;
+	tl: TimelineApi;
+	onOpenCalibration?: CamerasSectionProps["onOpenCalibration"];
+	setCameraSettings: CamerasSectionProps["setCameraSettings"];
 }) {
 	const te = useScopedT("editor");
 	// A small collapse affordance floated over the reused pane header.
@@ -1421,7 +1385,17 @@ function FacetBody({
 		</button>
 	);
 
-	if (facet === "layout") return wrap(collapse, <LayoutPane />);
+	if (facet === "layout")
+		return wrap(
+			collapse,
+			<LayoutPane
+				cameras={{
+					cameraSettings: tl.cameraSettings,
+					setCameraSettings,
+					onOpenCalibration,
+				}}
+			/>,
+		);
 	if (facet === "audio") return wrap(collapse, <AudioPane />);
 	if (facet === "cursor") return wrap(collapse, <CursorPane />);
 	if (facet === "transcript") return wrap(collapse, <TranscriptPane {...transcriptProps} />);
diff --git a/src/components/ai-edition/v4/LayoutSectionPane.test.tsx b/src/components/ai-edition/v4/LayoutSectionPane.test.tsx
new file mode 100644
index 000000000..9aea690bb
--- /dev/null
+++ b/src/components/ai-edition/v4/LayoutSectionPane.test.tsx
@@ -0,0 +1,129 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import type { CameraLayoutRegion } from "@/components/video-editor/types";
+import type { CameraSectionHandle } from "@/lib/ai-edition/store/useTimeline";
+import type { ProjectCamera } from "@/lib/ai-edition/timeline/cameraList";
+
+vi.mock("@/contexts/I18nContext", () => ({
+	useScopedT: (scope: string) => (key: string) => `${scope}.${key}`,
+}));
+
+vi.mock("../RightPanes", async (importOriginal) => ({
+	ChoiceRow: (await importOriginal<typeof import("../RightPanes")>()).ChoiceRow,
+}));
+
+import { LayoutSectionPane } from "./LayoutSectionPane";
+
+const camera = (index: number, available = true): ProjectCamera => ({
+	index,
+	label: `Cam ${index + 1}`,
+	path: available ? `/c${index}.mp4` : "",
+	available,
+});
+
+function setup(region: Partial<CameraLayoutRegion>, cameras: ProjectCamera[], blockPreset = false) {
+	const tl = {
+		setLayoutTemplate: vi.fn(async (handle: CameraSectionHandle) => handle),
+		setLayoutSlotCamera: vi.fn(async (handle: CameraSectionHandle) => handle),
+		resetLayoutSlotRects: vi.fn(async () => undefined),
+		removeRegion: vi.fn(async () => undefined),
+		selectRegion: vi.fn(),
+	};
+	const full: CameraLayoutRegion = {
+		id: "L1",
+		startMs: 0,
+		endMs: 2000,
+		template: "side-by-side",
+		slots: [{ camera: 0 }, { camera: 1 }],
+		...region,
+	};
+	render(
+		<LayoutSectionPane
+			tl={tl}
+			region={full}
+			cameras={cameras}
+			blockPreset={blockPreset}
+			onClose={vi.fn()}
+		/>,
+	);
+	return tl;
+}
+
+describe("LayoutSectionPane", () => {
+	it("shows one camera select per place", () => {
+		setup({}, [camera(0), camera(1), camera(2)]);
+		expect(screen.getAllByRole("combobox")).toHaveLength(2);
+		expect(screen.getByRole("combobox", { name: "settings.cameraLayout.placeLeft" })).toHaveValue(
+			"0",
+		);
+		expect(screen.getByRole("combobox", { name: "settings.cameraLayout.placeRight" })).toHaveValue(
+			"1",
+		);
+	});
+
+	it("choosing a template calls setLayoutTemplate", async () => {
+		const tl = setup({}, [camera(0), camera(1), camera(2)]);
+		fireEvent.click(screen.getByRole("button", { name: /timeline\.labels\.layoutCameraFullPip/ }));
+		expect(tl.setLayoutTemplate).toHaveBeenCalledWith(
+			{ kind: "cameraLayout", id: "L1" },
+			"camera-full-pip",
+			[0, 1, 2],
+		);
+		// The returned handle is the same section: the selection stays.
+		await waitFor(() => expect(tl.setLayoutTemplate).toHaveBeenCalledTimes(1));
+		expect(tl.selectRegion).not.toHaveBeenCalled();
+	});
+
+	it("moves the selection to the handle a change returns", async () => {
+		const tl = setup({}, [camera(0), camera(1)]);
+		tl.setLayoutSlotCamera.mockResolvedValueOnce({ kind: "cameraFullscreen", id: "F1" });
+		fireEvent.change(screen.getByRole("combobox", { name: "settings.cameraLayout.placeLeft" }), {
+			target: { value: "1" },
+		});
+		expect(tl.setLayoutSlotCamera).toHaveBeenCalledWith({ kind: "cameraLayout", id: "L1" }, 0, 1);
+		await waitFor(() => expect(tl.selectRegion).toHaveBeenCalledWith("cameraFullscreen", "F1"));
+	});
+
+	it("a slot whose camera is gone shows as unavailable", () => {
+		setup({ slots: [{ camera: 0 }, { camera: 1 }] }, [camera(0), camera(1, false)]);
+		const select = screen.getByRole("combobox", { name: "settings.cameraLayout.placeRight" });
+		expect(select).toHaveValue("1");
+		expect(
+			screen.getAllByRole("option", { name: "settings.cameraLayout.cameraUnavailable" }),
+		).not.toHaveLength(0);
+	});
+
+	it("side-by-side is disabled with one camera", () => {
+		setup({ template: "camera-full", slots: [{ camera: 0 }] }, [camera(0)]);
+		const button = screen.getByRole("button", { name: /timeline\.labels\.layoutSideBySide/ });
+		expect(button).toBeDisabled();
+		expect(screen.getByText("timeline.layoutMenu.needsCamerasHint")).toBeInTheDocument();
+	});
+
+	it("pip templates are disabled under dual-frame", () => {
+		setup({}, [camera(0), camera(1)], true);
+		expect(
+			screen.getByRole("button", { name: /timeline\.labels\.layoutScreenPip/ }),
+		).toBeDisabled();
+		expect(
+			screen.getByRole("button", { name: /timeline\.labels\.layoutCameraFullPip/ }),
+		).toBeDisabled();
+		expect(
+			screen.getByRole("button", { name: /timeline\.labels\.layoutCameraFull$/ }),
+		).toBeEnabled();
+		expect(screen.getByText("timeline.layoutMenu.blockLayoutHint")).toBeInTheDocument();
+	});
+
+	it("resets the windows only when a place has its own rect", () => {
+		const tl = setup(
+			{ slots: [{ camera: 0 }, { camera: 1, rect: { x: 0, y: 0, width: 0.3, height: 0.3 } }] },
+			[camera(0), camera(1)],
+		);
+		const reset = screen.getByRole("button", { name: "settings.cameraLayout.resetWindows" });
+		expect(reset).toBeEnabled();
+		fireEvent.click(reset);
+		expect(tl.resetLayoutSlotRects).toHaveBeenCalledWith("L1");
+	});
+});
diff --git a/src/components/ai-edition/v4/LayoutSectionPane.tsx b/src/components/ai-edition/v4/LayoutSectionPane.tsx
new file mode 100644
index 000000000..2b5126733
--- /dev/null
+++ b/src/components/ai-edition/v4/LayoutSectionPane.tsx
@@ -0,0 +1,205 @@
+// The inspector pane of a layout section: its template, one camera per place, and the
+// section's own actions. The Full Camera pane reuses `LayoutTemplateChoice`.
+
+import { RotateCcw, Trash2 } from "lucide-react";
+import { useId } from "react";
+import type { CameraLayoutRegion, CameraLayoutTemplate } from "@/components/video-editor/types";
+import { useScopedT } from "@/contexts/I18nContext";
+import type { useTimeline } from "@/lib/ai-edition/store/useTimeline";
+import type { ProjectCamera } from "@/lib/ai-edition/timeline/cameraList";
+import {
+	LAYOUT_TEMPLATES,
+	type LayoutTemplateBlock,
+	layoutTemplateBlock,
+} from "@/lib/ai-edition/timeline/layoutMenu";
+import shell from "../NewEditorShell.module.css";
+import { ChoiceRow } from "../RightPanes";
+import { layoutTemplateIcon, layoutTemplateLabel } from "./layoutTemplateUi";
+import { PANE_BODY_STYLE, PANE_BUTTON, paneHeader, paneStack } from "./paneParts";
+
+type TimelineApi = ReturnType<typeof useTimeline>;
+
+/** The four templates as one choice row; the ones that cannot apply are disabled, with the reason. */
+export function LayoutTemplateChoice({
+	current,
+	cameraCount,
+	blockPreset,
+	onPick,
+}: {
+	current: CameraLayoutTemplate;
+	/** How many cameras the section could show: its own plus the clip's available ones. */
+	cameraCount: number;
+	blockPreset: boolean;
+	onPick: (template: CameraLayoutTemplate) => void;
+}) {
+	const ts = useScopedT("settings");
+	const tt = useScopedT("timeline");
+	const hintId = useId();
+	const blocks = new Map<CameraLayoutTemplate, LayoutTemplateBlock>();
+	for (const template of LAYOUT_TEMPLATES) {
+		// The template in use stays pickable: it is where the section already is.
+		const block =
+			template === current ? null : layoutTemplateBlock(template, { cameraCount, blockPreset });
+		if (block) blocks.set(template, block);
+	}
+	const hintFor = (block: LayoutTemplateBlock) =>
+		block === "block-layout" ? tt("layoutMenu.blockLayoutHint") : tt("layoutMenu.needsCamerasHint");
+	const reasons = [...new Set(blocks.values())];
+	return paneStack(
+		ts("cameraLayout.template"),
+		<>
+			<ChoiceRow<CameraLayoutTemplate>
+				label={ts("cameraLayout.template")}
+				columns={2}
+				display="both"
+				describedBy={reasons.length > 0 ? hintId : undefined}
+				options={LAYOUT_TEMPLATES.map((template) => {
+					const block = blocks.get(template);
+					return {
+						value: template,
+						label: layoutTemplateLabel(tt, template),
+						icon: layoutTemplateIcon(template, 14),
+						disabled: block !== undefined,
+						title: block ? hintFor(block) : null,
+					};
+				})}
+				value={current}
+				onChange={onPick}
+			/>
+			{reasons.length > 0 ? (
+				<span id={hintId} style={{ fontSize: 12, color: "var(--muted)" }}>
+					{reasons.map(hintFor).join(" · ")}
+				</span>
+			) : null}
+		</>,
+	);
+}
+
+/** "Place 1 · large": the template says which places are big and which are small. */
+function placeLabel(
+	ts: (key: string, vars?: Record<string, string | number>) => string,
+	template: CameraLayoutTemplate,
+	index: number,
+): string {
+	const n = index + 1;
+	if (template === "side-by-side") {
+		return ts(index === 0 ? "cameraLayout.placeLeft" : "cameraLayout.placeRight", { n });
+	}
+	const large = template === "camera-full" || (template === "camera-full-pip" && index === 0);
+	return ts(large ? "cameraLayout.placeLarge" : "cameraLayout.placeSmall", { n });
+}
+
+export function LayoutSectionPane({
+	tl,
+	region,
+	cameras,
+	blockPreset,
+	onClose,
+}: {
+	tl: Pick<
+		TimelineApi,
+		| "setLayoutTemplate"
+		| "setLayoutSlotCamera"
+		| "resetLayoutSlotRects"
+		| "removeRegion"
+		| "selectRegion"
+	>;
+	region: CameraLayoutRegion;
+	/** The cameras of the clip the section sits on. */
+	cameras: ProjectCamera[];
+	blockPreset: boolean;
+	onClose: () => void;
+}) {
+	const ts = useScopedT("settings");
+	const tt = useScopedT("timeline");
+	const tc = useScopedT("common");
+	const te = useScopedT("editor");
+	const handle = { kind: "cameraLayout" as const, id: region.id };
+	const own = region.slots.map((slot) => slot.camera);
+	const available = cameras.filter((c) => c.available).map((c) => c.index);
+	const cameraCount = new Set([...own, ...available]).size;
+	const followHandle = (next: { kind: "cameraFullscreen" | "cameraLayout"; id: string }) => {
+		if (next.kind !== handle.kind || next.id !== handle.id) tl.selectRegion(next.kind, next.id);
+	};
+	return (
+		<div style={{ display: "flex", flexDirection: "column", minHeight: 0 }}>
+			{paneHeader(
+				layoutTemplateIcon(region.template, 16),
+				layoutTemplateLabel(tt, region.template),
+				onClose,
+				tc("actions.close"),
+			)}
+			<div style={PANE_BODY_STYLE}>
+				<LayoutTemplateChoice
+					current={region.template}
+					cameraCount={cameraCount}
+					blockPreset={blockPreset}
+					onPick={(template) =>
+						void tl.setLayoutTemplate(handle, template, available).then(followHandle)
+					}
+				/>
+				{region.slots.map((slot, index) => {
+					const label = placeLabel(ts, region.template, index);
+					const known = cameras.some((c) => c.index === slot.camera);
+					return (
+						// A place has no id of its own; its position is its identity.
+						<div key={index}>
+							{paneStack(
+								label,
+								<select
+									className={shell.control}
+									aria-label={label}
+									value={slot.camera}
+									onChange={(e) =>
+										void tl
+											.setLayoutSlotCamera(handle, index, Number(e.target.value))
+											.then(followHandle)
+									}
+								>
+									{cameras.map((camera) => (
+										<option
+											key={camera.index}
+											value={camera.index}
+											disabled={!camera.available && camera.index !== slot.camera}
+										>
+											{camera.available
+												? camera.label
+												: ts("cameraLayout.cameraUnavailable", { name: camera.label })}
+										</option>
+									))}
+									{known ? null : (
+										<option value={slot.camera} disabled>
+											{ts("cameraLayout.cameraUnavailable", {
+												name: ts("cameras.cameraN", { n: slot.camera + 1 }),
+											})}
+										</option>
+									)}
+								</select>,
+							)}
+						</div>
+					);
+				})}
+				<button
+					type="button"
+					className={PANE_BUTTON}
+					disabled={!region.slots.some((slot) => slot.rect)}
+					onClick={() => void tl.resetLayoutSlotRects(region.id)}
+				>
+					<RotateCcw size={16} />
+					{ts("cameraLayout.resetWindows")}
+				</button>
+				<button
+					type="button"
+					className={PANE_BUTTON}
+					onClick={() => {
+						void tl.removeRegion("cameraLayout", region.id);
+						onClose();
+					}}
+				>
+					<Trash2 size={16} style={{ color: "var(--danger)" }} />
+					{te("inspector.deleteRegion")}
+				</button>
+			</div>
+		</div>
+	);
+}
diff --git a/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx b/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx
index c3f98ca09..5a2af39aa 100644
--- a/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx
+++ b/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx
@@ -119,6 +119,7 @@ function renderTimeline(
 		annotationRegions: [annotation],
 		speedRegions: [],
 		cameraFullscreenRegions: [],
+		cameraLayoutRegions: [],
 		zoomRegions: [],
 		trimRanges: [],
 		hasEditRegions: true,
@@ -454,7 +455,7 @@ describe("V4Timeline create-from-toolbar", () => {
 		expect(tl.clearTimeline).toHaveBeenCalledTimes(1);
 	});
 
-	it("puts Clear timeline last, behind a divider, after the Add Full Camera button", () => {
+	it("puts Clear timeline last, behind a divider, after the Add Full Camera and Add layout buttons", () => {
 		renderTimeline(undefined, undefined, [CAMERA_ASSET]);
 		const toolbar = toolbarOf();
 		const buttons = Array.from(toolbar.querySelectorAll("button"));
@@ -463,7 +464,8 @@ describe("V4Timeline create-from-toolbar", () => {
 
 		const divider = clear.previousElementSibling;
 		expect(divider?.className).toContain("tlToolSep");
-		expect(divider?.previousElementSibling).toBe(
+		expect(divider?.previousElementSibling).toBe(screen.getByLabelText("buttons.addLayout"));
+		expect(divider?.previousElementSibling?.previousElementSibling).toBe(
 			screen.getByLabelText("buttons.addCameraFullscreen"),
 		);
 		expect(dividersIn(toolbar)).toHaveLength(2);
@@ -658,6 +660,7 @@ describe("V4Timeline audio lane drag", () => {
 			annotationRegions: [],
 			speedRegions: [],
 			cameraFullscreenRegions: [],
+			cameraLayoutRegions: [],
 			zoomRegions: [],
 			trimRanges: [],
 			selection: null,
diff --git a/src/components/ai-edition/v4/V4Timeline.layout.test.tsx b/src/components/ai-edition/v4/V4Timeline.layout.test.tsx
new file mode 100644
index 000000000..82d4ecc70
--- /dev/null
+++ b/src/components/ai-edition/v4/V4Timeline.layout.test.tsx
@@ -0,0 +1,221 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+const VIEWPORT_PX = 900;
+const TOTAL_SEC = 100; // 9 px per second
+
+// A bare key, with the variables appended, so a label built from keys stays readable.
+vi.mock("@/contexts/I18nContext", () => ({
+	useScopedT: () => (key: string, vars?: Record<string, string | number>) =>
+		vars ? `${key}:${Object.values(vars).join(",")}` : key,
+}));
+const toastError = vi.hoisted(() => vi.fn());
+vi.mock("sonner", () => ({ toast: { error: toastError, info: vi.fn(), success: vi.fn() } }));
+vi.mock("@/hooks/useAudioPeaks", () => ({ useAudioPeaks: () => null }));
+
+import { ShortcutsProvider } from "@/contexts/ShortcutsContext";
+import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
+import type { useTimeline } from "@/lib/ai-edition/store/useTimeline";
+import { V4Timeline } from "./V4Timeline";
+
+beforeAll(() => {
+	globalThis.ResizeObserver = class {
+		observe() {
+			/* noop */
+		}
+		unobserve() {
+			/* noop */
+		}
+		disconnect() {
+			/* noop */
+		}
+	} as unknown as typeof ResizeObserver;
+	Object.defineProperty(HTMLElement.prototype, "clientWidth", {
+		configurable: true,
+		get: () => VIEWPORT_PX,
+	});
+	Object.defineProperty(HTMLElement.prototype, "getBoundingClientRect", {
+		configurable: true,
+		value: () => ({
+			x: 0,
+			y: 0,
+			left: 0,
+			top: 0,
+			right: VIEWPORT_PX,
+			bottom: 100,
+			width: VIEWPORT_PX,
+			height: 100,
+			toJSON() {
+				/* unused */
+			},
+		}),
+	});
+	vi.spyOn(HTMLCanvasElement.prototype, "getContext").mockImplementation(
+		() =>
+			({
+				measureText: (text: string) => ({ width: text.length * 6 }),
+			}) as unknown as CanvasRenderingContext2D,
+	);
+});
+
+beforeEach(() => {
+	useProjectStore.setState({ currentTimeSec: 30 });
+});
+
+afterEach(() => {
+	cleanup();
+	toastError.mockClear();
+});
+
+const CLIP = {
+	id: "c1",
+	assetId: "a1",
+	timelineStartSec: 0,
+	timelineEndSec: TOTAL_SEC,
+	sourceStartSec: 0,
+	sourceEndSec: TOTAL_SEC,
+};
+const track = (path: string, extra: Record<string, unknown> = {}) => ({
+	sourcePath: path,
+	startMs: 0,
+	offsetMs: 0,
+	visible: true,
+	...extra,
+});
+const ONE_CAMERA = {
+	id: "a1",
+	label: "rec",
+	durationSec: TOTAL_SEC,
+	cameraTrack: track("/tmp/cam1.webm"),
+};
+const TWO_CAMERAS = {
+	...ONE_CAMERA,
+	additionalCameraTracks: [track("/tmp/cam2.webm", { label: "Desk" })],
+};
+const LAYOUT = {
+	id: "cl1",
+	startMs: 20_000,
+	endMs: 60_000,
+	template: "camera-full-pip",
+	slots: [{ camera: 1 }, { camera: 0 }],
+	assetId: "a1",
+};
+
+function renderTimeline(
+	assets: Array<Record<string, unknown>>,
+	layouts: unknown[] = [],
+	fullCameras: unknown[] = [],
+) {
+	const tl = {
+		clips: [CLIP],
+		transcripts: [],
+		assets,
+		annotationRegions: [],
+		speedRegions: [],
+		cameraFullscreenRegions: fullCameras,
+		cameraLayoutRegions: layouts,
+		zoomRegions: [],
+		trimRanges: [],
+		hasEditRegions: false,
+		selection: null,
+		multiSelection: [],
+		clipSelection: null,
+		audioTracks: [],
+		selectedAudioTrackId: null,
+		selectAudioTrack: vi.fn(),
+		clearSelection: vi.fn(),
+		selectRegion: vi.fn(),
+		selectClip: vi.fn(),
+		addCameraFullscreen: vi.fn(async () => "added"),
+		addCameraLayout: vi.fn(async () => "added"),
+		updateCameraLayoutSpan: vi.fn(async () => undefined),
+	};
+	render(
+		<ShortcutsProvider>
+			<V4Timeline
+				tl={tl as unknown as ReturnType<typeof useTimeline>}
+				setCurrentTime={vi.fn()}
+				playing={false}
+				onTogglePlay={vi.fn()}
+				onEditClip={vi.fn()}
+				onAddVoiceover={vi.fn()}
+			/>
+		</ShortcutsProvider>,
+	);
+	return tl;
+}
+
+describe("V4Timeline layout lane", () => {
+	it("renders layout pills in the full camera lane", () => {
+		renderTimeline([TWO_CAMERAS], [LAYOUT], [{ id: "cf1", startMs: 70_000, endMs: 90_000 }]);
+		// The Full Camera pill keeps its (now translated) label next to the layout pill.
+		expect(screen.getByText("labels.cameraFullscreen")).toBeInTheDocument();
+		expect(screen.getByText(/labels\.layoutCameraFullPip/)).toBeInTheDocument();
+	});
+
+	it("names the pill after its template and the cameras of its places", () => {
+		renderTimeline([TWO_CAMERAS], [LAYOUT]);
+		const pill = screen.getByText(
+			"labels.layoutCameraFullPip · cameras.cameraNamed:2,Desk, cameras.cameraN:1",
+		);
+		expect(pill).toBeInTheDocument();
+	});
+
+	it("selects a layout pill as a cameraLayout region", () => {
+		const tl = renderTimeline([TWO_CAMERAS], [LAYOUT]);
+		const pill = screen.getByText(/labels\.layoutCameraFullPip/).closest("[role='button']");
+		fireEvent.pointerDown(pill as Element, { clientX: 0 });
+		window.dispatchEvent(new MouseEvent("pointerup", { clientX: 0 }));
+		expect(tl.selectRegion).toHaveBeenCalledWith("cameraLayout", "cl1", { additive: false });
+	});
+
+	it("a layout pill drag calls updateCameraLayoutSpan", () => {
+		const tl = renderTimeline([TWO_CAMERAS], [LAYOUT]);
+		const pill = screen.getByText(/labels\.layoutCameraFullPip/).closest("[role='button']");
+		fireEvent.pointerDown(pill as Element, { clientX: 0 });
+		window.dispatchEvent(new MouseEvent("pointermove", { clientX: 90 }));
+		window.dispatchEvent(new MouseEvent("pointerup", { clientX: 90 }));
+		expect(tl.updateCameraLayoutSpan).toHaveBeenCalledTimes(1);
+		const [id, startMs, endMs] = tl.updateCameraLayoutSpan.mock.calls[0] as unknown as [
+			string,
+			number,
+			number,
+		];
+		expect(id).toBe("cl1");
+		expect(startMs).toBeCloseTo(30_000, -2);
+		expect(endMs - startMs).toBeCloseTo(40_000, -2);
+	});
+
+	it("the add-layout menu disables multi-camera templates for a one-camera project", async () => {
+		renderTimeline([ONE_CAMERA]);
+		fireEvent.click(screen.getByLabelText("buttons.addLayout"));
+		const sideBySide = await screen.findByRole("button", { name: /labels\.layoutSideBySide/ });
+		expect(sideBySide).toBeDisabled();
+		expect(screen.getByRole("button", { name: /labels\.layoutCameraFullPip/ })).toBeDisabled();
+		expect(screen.getByRole("button", { name: /labels\.layoutScreenPip/ })).toBeEnabled();
+		expect(screen.getByRole("button", { name: /labels\.layoutCameraFull$/ })).toBeEnabled();
+	});
+
+	it("adds a camera-full-pip layout desk camera first and reports an occupied spot", async () => {
+		const tl = renderTimeline([TWO_CAMERAS]);
+		tl.addCameraLayout.mockResolvedValueOnce("occupied");
+		fireEvent.click(screen.getByLabelText("buttons.addLayout"));
+		fireEvent.click(await screen.findByRole("button", { name: /labels\.layoutCameraFullPip/ }));
+		expect(tl.addCameraLayout).toHaveBeenCalledWith("camera-full-pip", [1, 0], expect.any(Number));
+		await waitFor(() =>
+			expect(toastError).toHaveBeenCalledWith(
+				"errors.cannotPlaceCameraSection",
+				expect.objectContaining({ description: "errors.cameraSectionExistsAtLocation" }),
+			),
+		);
+	});
+
+	it("shows a notice when the Add Full Camera button is refused", async () => {
+		const tl = renderTimeline([ONE_CAMERA]);
+		tl.addCameraFullscreen.mockResolvedValueOnce("occupied" as never);
+		fireEvent.click(screen.getByLabelText("buttons.addCameraFullscreen"));
+		await waitFor(() => expect(toastError).toHaveBeenCalled());
+	});
+});
diff --git a/src/components/ai-edition/v4/V4Timeline.tsx b/src/components/ai-edition/v4/V4Timeline.tsx
index f50942b3d..861d53d63 100644
--- a/src/components/ai-edition/v4/V4Timeline.tsx
+++ b/src/components/ai-edition/v4/V4Timeline.tsx
@@ -3,6 +3,7 @@ import {
 	Clock,
 	Crosshair,
 	Eraser,
+	LayoutTemplate,
 	Loader2,
 	Maximize2,
 	MessageSquare,
@@ -31,7 +32,7 @@ import { toast } from "sonner";
 import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
 import { Tooltip, TooltipProvider } from "@/components/ui/tooltip";
 import { toFileUrl } from "@/components/video-editor/projectPersistence";
-import { ZOOM_DEPTH_SCALES } from "@/components/video-editor/types";
+import { type CameraLayoutTemplate, ZOOM_DEPTH_SCALES } from "@/components/video-editor/types";
 import { useScopedT } from "@/contexts/I18nContext";
 import { useShortcuts } from "@/contexts/ShortcutsContext";
 import { useAudioPeaks } from "@/hooks/useAudioPeaks";
@@ -56,7 +57,15 @@ import { useEditorSettings } from "@/lib/ai-edition/store/useEditorSettings";
 import type { useTimeline } from "@/lib/ai-edition/store/useTimeline";
 import { collectAutoZoomSuggestionsForLatestDocument } from "@/lib/ai-edition/timeline/apply-auto-zooms";
 import { hasAnyClipWithCamera } from "@/lib/ai-edition/timeline/camera";
+import { type ProjectCamera, projectCameras } from "@/lib/ai-edition/timeline/cameraList";
+import { showCameraSectionOutcome } from "@/lib/ai-edition/timeline/cameraSectionNotice";
 import { formatSec } from "@/lib/ai-edition/timeline/format";
+import {
+	camerasForLayoutMenu,
+	defaultLayoutCameras,
+	LAYOUT_TEMPLATES,
+	layoutTemplateBlock,
+} from "@/lib/ai-edition/timeline/layoutMenu";
 import {
 	newRegionDurationSec,
 	setTimelineScale,
@@ -68,12 +77,15 @@ import {
 	resolveTimelineSpanToTrim,
 	ventilateTimelineSpanToTrims,
 } from "@/lib/ai-edition/timeline/trim-mapping";
+import type { AnchoredCameraLayoutRegion } from "@/lib/cameraLayouts";
 import { normalizeCameraRotation } from "@/lib/cameraOrientation";
+import { isWebcamBlockLayout } from "@/lib/compositeLayout";
 import { formatBinding } from "@/lib/shortcuts";
 import { nativeBridgeClient } from "@/native/client";
 import { TransportBar } from "../TransportBar";
 import type { VideoSource } from "../VirtualPreview";
 import styles from "./EditorShellV4.module.css";
+import { layoutTemplateIcon, layoutTemplateLabel } from "./layoutTemplateUi";
 
 // The AI option's prompt — sent straight to the chat agent via the prompt-bus.
 //
@@ -592,7 +604,7 @@ const AudioLanePill = memo(function AudioLanePill({
 
 interface LanePill {
 	id: string;
-	kind: "annotation" | "speed" | "trim" | "zoom" | "cameraFullscreen";
+	kind: "annotation" | "speed" | "trim" | "zoom" | "cameraFullscreen" | "cameraLayout";
 	start: number;
 	end: number;
 	label: string;
@@ -600,6 +612,8 @@ interface LanePill {
 	sourceIds: string[];
 	/** Desk-view section: the camera is turned 180 degrees. */
 	rotated?: boolean;
+	/** Layout pills: which template, for the icon. */
+	template?: CameraLayoutTemplate;
 }
 
 export function V4Timeline({
@@ -671,6 +685,32 @@ export function V4Timeline({
 	} | null>(null);
 	const { settings, set: setSettings } = useEditorSettings();
 
+	// The "Add layout" menu. The cameras of the clip under the playhead (else the nearest with some) are read when the
+	// menu opens and again on a pick, so no playback frame re-renders the timeline for it.
+	const [layoutMenuOpen, setLayoutMenuOpen] = useState(false);
+	const [layoutMenuCameras, setLayoutMenuCameras] = useState<ProjectCamera[]>([]);
+	const availableCamerasAtPlayhead = useCallback((): ProjectCamera[] => {
+		return camerasForLayoutMenu(tl.clips, tl.assets, useProjectStore.getState().currentTimeSec, ts);
+	}, [tl.clips, tl.assets, ts]);
+	const openLayoutMenu = useCallback(
+		(open: boolean) => {
+			if (open) setLayoutMenuCameras(availableCamerasAtPlayhead());
+			setLayoutMenuOpen(open);
+		},
+		[availableCamerasAtPlayhead],
+	);
+	const templateLabel = (template: CameraLayoutTemplate): string =>
+		layoutTemplateLabel(t, template);
+	const addLayout = async (template: CameraLayoutTemplate) => {
+		setLayoutMenuOpen(false);
+		const cameras = defaultLayoutCameras(
+			template,
+			availableCamerasAtPlayhead().map((c) => c.index),
+		);
+		const outcome = await tl.addCameraLayout(template, cameras, newRegionDurationSec());
+		showCameraSectionOutcome(outcome, t);
+	};
+
 	const [autoEnhanceOpen, setAutoEnhanceOpen] = useState(false);
 	const [audioMenuOpen, setAudioMenuOpen] = useState(false);
 	const [autoBusy, setAutoBusy] = useState(false);
@@ -760,11 +800,35 @@ export function V4Timeline({
 			kind: "cameraFullscreen",
 			start: p.start,
 			end: p.end,
-			label: "Full Camera",
+			label: t("labels.cameraFullscreen"),
 			sourceIds: p.ids,
 			rotated: normalizeCameraRotation(p.member.rotation) === 180,
 		}),
 	);
+	// Layout sections: "<template> · <camera labels of its places>", the cameras named from the
+	// asset the section is anchored to (else the first asset that has a camera).
+	const cameraLayoutPills: LanePill[] = coalesceRegionsForRuler(tl.cameraLayoutRegions).map((p) => {
+		const member = p.member as AnchoredCameraLayoutRegion;
+		const asset =
+			tl.assets.find((a) => a.id === member.assetId) ??
+			tl.assets.find((a) => a.cameraTrack !== undefined);
+		const cameras = projectCameras(asset, ts);
+		const names = member.slots.map(
+			(slot) =>
+				cameras.find((c) => c.index === slot.camera)?.label ??
+				ts("cameras.cameraN", { n: slot.camera + 1 }),
+		);
+		return {
+			id: p.ids[0],
+			kind: "cameraLayout",
+			start: p.start,
+			end: p.end,
+			label: `${templateLabel(member.template)} · ${names.join(", ")}`,
+			sourceIds: p.ids,
+			template: member.template,
+		};
+	});
+	const layoutLanePills = [...cameraFullscreenPills, ...cameraLayoutPills];
 	const zoomPills: LanePill[] = coalesceRegionsForRuler(tl.zoomRegions).map((p) => ({
 		id: p.ids[0],
 		kind: "zoom",
@@ -992,6 +1056,8 @@ export function V4Timeline({
 					await tl.updateAnnotationSpan(pill.id, s * 1000, en * 1000);
 				else if (pill.kind === "cameraFullscreen")
 					await tl.updateCameraFullscreenSpan(pill.id, s * 1000, en * 1000);
+				else if (pill.kind === "cameraLayout")
+					await tl.updateCameraLayoutSpan(pill.id, s * 1000, en * 1000);
 				else {
 					// Trims are stored in source-time per asset but manipulated on the
 					// timeline like every other pill. Ventilate the new span across the
@@ -1419,16 +1485,18 @@ export function V4Timeline({
 				? styles.laneSpeed
 				: kind === "trim"
 					? styles.laneTrim
-					: kind === "cameraFullscreen"
+					: kind === "cameraFullscreen" || kind === "cameraLayout"
 						? styles.laneCameraFullscreen
 						: styles.laneZoom;
-	const pillIcon = (kind: LanePill["kind"], rotated?: boolean) =>
+	const pillIcon = (kind: LanePill["kind"], rotated?: boolean, template?: CameraLayoutTemplate) =>
 		kind === "annotation" ? (
 			<MessageSquare size={12} />
 		) : kind === "speed" ? (
 			<Clock size={12} />
 		) : kind === "trim" ? (
 			<Scissors size={12} />
+		) : kind === "cameraLayout" ? (
+			layoutTemplateIcon(template ?? "screen-pip")
 		) : kind === "cameraFullscreen" ? (
 			rotated ? (
 				<RotateCw size={12} />
@@ -1721,7 +1789,7 @@ export function V4Timeline({
 				) : null}
 				{seg.showContent && roomForLabel ? (
 					<>
-						{pillIcon(p.kind, p.rotated)}
+						{pillIcon(p.kind, p.rotated, p.template)}
 						<span className={styles.lanePillLabel}>{p.label}</span>
 					</>
 				) : null}
@@ -2027,12 +2095,73 @@ export function V4Timeline({
 										type="button"
 										className={styles.tlToolBtn}
 										aria-label={t("buttons.addCameraFullscreen")}
-										onClick={() => void tl.addCameraFullscreen(newRegionDurationSec())}
+										onClick={() =>
+											void tl.addCameraFullscreen(newRegionDurationSec()).then((outcome) => {
+												showCameraSectionOutcome(outcome, t);
+											})
+										}
 									>
 										<Maximize2 size={16} />
 									</button>
 								</Tooltip>
 							) : null}
+							{hasAnyCamera ? (
+								<Popover open={layoutMenuOpen} onOpenChange={openLayoutMenu}>
+									<Tooltip content={t("buttons.addLayout")}>
+										<PopoverTrigger asChild>
+											<button
+												type="button"
+												className={styles.tlToolBtn}
+												aria-label={t("buttons.addLayout")}
+											>
+												<LayoutTemplate size={16} />
+											</button>
+										</PopoverTrigger>
+									</Tooltip>
+									<PopoverContent
+										align="start"
+										sideOffset={6}
+										animated={false}
+										className="w-auto border-0 bg-transparent p-0 shadow-none"
+									>
+										<div
+											className={styles.recMenu}
+											style={{ position: "relative", bottom: "auto", width: 244 }}
+										>
+											{LAYOUT_TEMPLATES.map((template) => {
+												const block = layoutTemplateBlock(template, {
+													cameraCount: layoutMenuCameras.length,
+													blockPreset: isWebcamBlockLayout(settings.webcamLayoutPreset),
+												});
+												const hint =
+													block === "block-layout"
+														? t("layoutMenu.blockLayoutHint")
+														: block === "needs-cameras"
+															? t("layoutMenu.needsCamerasHint")
+															: undefined;
+												return (
+													<button
+														key={template}
+														type="button"
+														className={styles.recMenuRow}
+														disabled={block !== null}
+														title={hint}
+														onClick={() => void addLayout(template)}
+													>
+														{pillIcon("cameraLayout", false, template)}
+														<span style={{ display: "flex", flexDirection: "column", gap: 1 }}>
+															<span style={{ fontWeight: 600 }}>{templateLabel(template)}</span>
+															{hint ? (
+																<span style={{ fontSize: 12, color: "var(--muted)" }}>{hint}</span>
+															) : null}
+														</span>
+													</button>
+												);
+											})}
+										</div>
+									</PopoverContent>
+								</Popover>
+							) : null}
 							{/* Last, behind a divider: every button before it adds a region, this one
 							    clears them. Absent with its divider, not greyed out, when there is
 							    nothing to clear. One write in the store, so one Ctrl+Z restores every
@@ -2169,7 +2298,7 @@ export function V4Timeline({
 									    that `addCameraFullscreen` now refuses (#353). The toolbar button is
 									    already disabled; this keeps the lane from contradicting it. */}
 									{renderPills(
-										cameraFullscreenPills,
+										layoutLanePills,
 										hasAnyCamera
 											? t("hints.pressCameraFullscreen", {
 													key: formatBinding(shortcuts.addCameraFullscreen, isMac),
diff --git a/src/components/ai-edition/v4/V4Timeline.waveform.test.tsx b/src/components/ai-edition/v4/V4Timeline.waveform.test.tsx
index b84915af2..b2dc89abe 100644
--- a/src/components/ai-edition/v4/V4Timeline.waveform.test.tsx
+++ b/src/components/ai-edition/v4/V4Timeline.waveform.test.tsx
@@ -120,6 +120,7 @@ function renderBars(atGainDb: number): string[] {
 		annotationRegions: [],
 		speedRegions: [],
 		cameraFullscreenRegions: [],
+		cameraLayoutRegions: [],
 		zoomRegions: [],
 		trimRanges: [],
 		selection: null,
diff --git a/src/components/ai-edition/v4/layoutTemplateUi.tsx b/src/components/ai-edition/v4/layoutTemplateUi.tsx
new file mode 100644
index 000000000..e0c507cb1
--- /dev/null
+++ b/src/components/ai-edition/v4/layoutTemplateUi.tsx
@@ -0,0 +1,33 @@
+// How a layout template looks in the editor: its name (timeline scope) and its icon. Shared by
+// the timeline's pills and "Add layout" menu and by the inspector.
+
+import { Columns2, Layers, Maximize2, PictureInPicture2 } from "lucide-react";
+import type { CameraLayoutTemplate } from "@/components/video-editor/types";
+
+type Translate = (key: string) => string;
+
+export function layoutTemplateLabel(t: Translate, template: CameraLayoutTemplate): string {
+	switch (template) {
+		case "screen-pip":
+			return t("labels.layoutScreenPip");
+		case "camera-full":
+			return t("labels.layoutCameraFull");
+		case "camera-full-pip":
+			return t("labels.layoutCameraFullPip");
+		case "side-by-side":
+			return t("labels.layoutSideBySide");
+	}
+}
+
+export function layoutTemplateIcon(template: CameraLayoutTemplate, size = 12) {
+	switch (template) {
+		case "camera-full":
+			return <Maximize2 size={size} />;
+		case "camera-full-pip":
+			return <Layers size={size} />;
+		case "side-by-side":
+			return <Columns2 size={size} />;
+		case "screen-pip":
+			return <PictureInPicture2 size={size} />;
+	}
+}
diff --git a/src/components/ai-edition/v4/paneParts.tsx b/src/components/ai-edition/v4/paneParts.tsx
new file mode 100644
index 000000000..c76455e31
--- /dev/null
+++ b/src/components/ai-edition/v4/paneParts.tsx
@@ -0,0 +1,105 @@
+import { X } from "lucide-react";
+import type { CSSProperties, ReactNode } from "react";
+import shell from "../NewEditorShell.module.css";
+import styles from "./EditorShellV4.module.css";
+
+export function paneHeader(
+	icon: ReactNode,
+	title: string,
+	onClose: () => void,
+	closeLabel: string,
+) {
+	return (
+		<header
+			style={{
+				display: "flex",
+				alignItems: "center",
+				gap: 8,
+				padding: "14px 16px 12px",
+				borderBottom: "1px solid var(--border-soft)",
+				// Le corps défile sous l'en-tête : sans ça, l'en-tête se comprime avec lui.
+				flexShrink: 0,
+			}}
+		>
+			<span style={{ display: "grid", placeItems: "center", color: "var(--muted)" }}>{icon}</span>
+			<h2
+				style={{
+					margin: 0,
+					flex: 1,
+					fontSize: 14,
+					fontWeight: 600,
+					color: "var(--fg-emphasis)",
+					letterSpacing: "-0.01em",
+				}}
+			>
+				{title}
+			</h2>
+			<button
+				type="button"
+				className={styles.iconBtn}
+				title={closeLabel}
+				aria-label={closeLabel}
+				onClick={onClose}
+				style={{
+					width: 30,
+					height: 30,
+				}}
+			>
+				<X size={16} />
+			</button>
+		</header>
+	);
+}
+
+export function paneRow(label: string, control: ReactNode) {
+	return (
+		<div
+			style={{
+				display: "flex",
+				alignItems: "center",
+				justifyContent: "space-between",
+				gap: 10,
+			}}
+		>
+			<span style={{ fontSize: 13, color: "var(--fg-2)", fontWeight: 500 }}>{label}</span>
+			{control}
+		</div>
+	);
+}
+
+/** Un libellé au-dessus de son contrôle, pour ceux qui prennent toute la largeur du panneau
+ *  (une `ChoiceRow`) : à côté d'un libellé, ils n'auraient plus la place de montrer leurs choix.
+ *  `value` nomme le choix courant quand les boutons ne font que le dessiner. */
+export function paneStack(label: string, control: ReactNode, value?: string) {
+	return (
+		<div style={{ display: "flex", flexDirection: "column", gap: 6 }}>
+			<span style={{ fontSize: 13, color: "var(--fg-2)", fontWeight: 500 }}>
+				{label}
+				{value ? <span className={shell.sectionLabelValue}>{value}</span> : null}
+			</span>
+			{control}
+		</div>
+	);
+}
+
+/** Every action of the selection pane, delete included: the red icon says it destroys; a red
+ *  slab outshouted every setting above it. */
+export const PANE_BUTTON = `${shell.btn} ${shell.btnSecondary}`;
+
+// Le panneau découpe son contenu (coins arrondis + flou), donc un corps sans ascenseur perd
+// silencieusement ce qui dépasse — c'est ce qui arrivait au pane d'annotation, le plus haut de
+// tous, dès qu'on réduisait la fenêtre. L'en-tête reste fixe, le corps défile, comme les
+// panneaux de facette (cf. `.paneBody` de NewEditorShell).
+export const PANE_BODY_STYLE: CSSProperties = {
+	padding: "16px",
+	display: "flex",
+	flexDirection: "column",
+	gap: 16,
+	flex: "1 1 auto",
+	minHeight: 0,
+	overflowY: "auto",
+	overflowX: "hidden",
+	overscrollBehavior: "contain",
+	scrollbarWidth: "thin",
+	scrollbarColor: "var(--border) transparent",
+};
diff --git a/src/components/video-editor/types.ts b/src/components/video-editor/types.ts
index a8bf36b4b..cb612d1af 100644
--- a/src/components/video-editor/types.ts
+++ b/src/components/video-editor/types.ts
@@ -335,6 +335,61 @@ export interface CameraFullscreenRegion {
 	deskLabel?: false;
 }
 
+export type CameraLayoutTemplate =
+	| "screen-pip"
+	| "camera-full"
+	| "camera-full-pip"
+	| "side-by-side";
+
+/** A rectangle in fractions (0..1) of the output frame. */
+export interface NormalizedRect {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+
+/** One camera placed in a layout; `rect` overrides the template's own position. */
+export interface CameraLayoutSlot {
+	/** 0 = camera 1, k >= 1 = additional camera k. */
+	camera: number;
+	rect?: NormalizedRect;
+}
+
+/** A span of the timeline that lays several cameras out with a template. */
+export interface CameraLayoutRegion {
+	id: string;
+	startMs: number;
+	endMs: number;
+	template: CameraLayoutTemplate;
+	slots: CameraLayoutSlot[];
+	/** Desk view: `camera-full` only. */
+	rotation?: CameraRotation;
+	mirror?: CameraMirrorMode;
+	deskLabel?: false;
+}
+
+/** A point in fractions (0..1) of the camera image. */
+export interface CameraPoint {
+	x: number;
+	y: number;
+}
+
+/** Four corners (top-left, top-right, bottom-right, bottom-left) of a flat subject in the image. */
+export interface CameraPerspective {
+	corners: [CameraPoint, CameraPoint, CameraPoint, CameraPoint];
+	/** Width/height of the corrected picture. */
+	aspect: number;
+	margin?: number;
+}
+
+export interface CameraSettings {
+	rotation?: CameraRotation;
+	mirror?: boolean;
+	crop?: CropRegion;
+	perspective?: CameraPerspective;
+}
+
 export type AnnotationType = "text" | "image" | "figure" | "blur";
 
 export type ArrowDirection =
diff --git a/src/i18n/locales/ar/dialogs.json b/src/i18n/locales/ar/dialogs.json
index cf7c6f554..d3b99ca56 100644
--- a/src/i18n/locales/ar/dialogs.json
+++ b/src/i18n/locales/ar/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "ملفات الصوت",
 		"openscreenProject": "مشروع OpenScreen",
 		"allFiles": "جميع الملفات"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "تصحيح المنظور – {{camera}}",
+		"titleCrop": "اقتصاص – {{camera}}",
+		"loading": "جارٍ تحميل صورة الكاميرا…",
+		"loadFailed": "تعذّر تحميل صورة الكاميرا.",
+		"perspectiveHelp": "اسحب الزوايا الأربع إلى زوايا الورقة أو المكتب. تحرّك مفاتيح الأسهم الزاوية المحددة بكسلًا واحدًا، ومع Shift عشرة.",
+		"cropIgnored": "لهذه الكاميرا قص؛ ويُتجاهل القص ما دام المنظور مضبوطًا.",
+		"cropHelp": "اسحب الإطار أو مقابضه فوق جزء الصورة الذي تريد الاحتفاظ به. تحرّكه مفاتيح الأسهم، وتغيّر Shift مع الأسهم حجمه.",
+		"corners": {
+			"topLeft": "الزاوية العلوية اليسرى",
+			"topRight": "الزاوية العلوية اليمنى",
+			"bottomRight": "الزاوية السفلية اليمنى",
+			"bottomLeft": "الزاوية السفلية اليسرى"
+		},
+		"format": "التنسيق المستهدف",
+		"formats": {
+			"a4Portrait": "A4 طولي",
+			"a4Landscape": "A4 عرضي",
+			"free": "حر"
+		},
+		"freeRatio": "النسبة (العرض ÷ الارتفاع)",
+		"margin": "الهامش",
+		"preview": "معاينة",
+		"loupe": "عدسة مكبّرة",
+		"cropArea": "منطقة الاقتصاص",
+		"invalidQuad": "الزوايا متقاطعة أو على خط واحد أو تشكّل شكلًا مقعّرًا (غير محدّب). رتّبها على شكل رباعي محدّب لتتمكن من التطبيق.",
+		"reset": "إعادة تعيين",
+		"apply": "تطبيق",
+		"invalidRatio": "أدخل نسبة بين {{min}} و{{max}}.",
+		"detectMarkers": "اكتشاف العلامات",
+		"printMarkerSheet": "طباعة ورقة العلامات",
+		"markersFound": "تم العثور على العلامات الأربع؛ وُضعت الزوايا عليها.",
+		"markersNotFound": "لم يتم العثور على العلامات الأربع (0–3) كلها. تأكد من أنها داخل الصورة بالكامل ومسطحة ومضاءة بشكل متساوٍ. بقيت الزوايا كما هي.",
+		"markerSheetInstruction": "قصّ على الخطوط المتقطعة. ضع الزاوية الداخلية لكل علامة على زاويتها المكتوبة."
 	}
 }
diff --git a/src/i18n/locales/ar/editor.json b/src/i18n/locales/ar/editor.json
index 0de8bfa88..dd736ca22 100644
--- a/src/i18n/locales/ar/editor.json
+++ b/src/i18n/locales/ar/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "معاينة الفيديو",
 		"webcamPreview": "معاينة الكاميرا",
+		"layoutPlace": "نافذة الكاميرا — اسحب للتحريك",
+		"layoutPlaceResize": "تغيير حجم نافذة الكاميرا",
 		"mediaError": {
 			"title": "توقّفت المعاينة",
 			"description": "تعذّر فك ترميز الفيديو. قد يكون الملف تالفًا، أو ما زال قيد الكتابة، أو لم يعد في المكان الذي يتوقعه المشروع — مشروعك نفسه سليم.",
diff --git a/src/i18n/locales/ar/settings.json b/src/i18n/locales/ar/settings.json
index 458821341..6e8ae7f3c 100644
--- a/src/i18n/locales/ar/settings.json
+++ b/src/i18n/locales/ar/settings.json
@@ -462,5 +462,27 @@
 		"dark": "داكنة",
 		"light": "فاتحة",
 		"custom": "مخصصة"
+	},
+	"cameraLayout": {
+		"template": "التخطيط",
+		"placeLarge": "المكان {{n}} · كبير",
+		"placeSmall": "المكان {{n}} · صغير",
+		"placeLeft": "المكان {{n}} · يسار",
+		"placeRight": "المكان {{n}} · يمين",
+		"cameraUnavailable": "{{name}} (غير متاح)",
+		"resetWindows": "إعادة ضبط النوافذ"
+	},
+	"cameras": {
+		"cameraN": "الكاميرا {{n}}",
+		"cameraNamed": "الكاميرا {{n}} · {{label}}",
+		"title": "الكاميرات",
+		"unavailable": "غير متاح",
+		"camera1Hint": "تدوير الكاميرا 1 وقلبها وقصها في عناصر التحكم أعلاه.",
+		"rotation": "التدوير",
+		"mirror": "قلب",
+		"crop": "قص…",
+		"perspective": "تصحيح المنظور…",
+		"reset": "إعادة تعيين",
+		"cropOffWithPerspective": "لا يكون للقص أي تأثير ما دام المنظور مضبوطًا."
 	}
 }
diff --git a/src/i18n/locales/ar/timeline.json b/src/i18n/locales/ar/timeline.json
index 1dbdb6882..5784ec740 100644
--- a/src/i18n/locales/ar/timeline.json
+++ b/src/i18n/locales/ar/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "إضافة قص: يزيل جزءًا من الفيديو عند الوقت الحالي",
 		"addAnnotation": "إضافة نص أو سهم أو صورة أو تمويه عند الوقت الحالي",
 		"addSpeed": "إضافة تغيير في السرعة عند الوقت الحالي",
-		"addCameraFullscreen": "إضافة كاميرا كاملة الشاشة: تعرض الكاميرا بملء الشاشة عند الوقت الحالي"
+		"addCameraFullscreen": "إضافة كاميرا كاملة الشاشة: تعرض الكاميرا بملء الشاشة عند الوقت الحالي",
+		"addLayout": "إضافة تخطيط: ترتيب الشاشة والكاميرات لمقطع"
 	},
 	"hints": {
 		"pressZoom": "اضغط {{key}} لإضافة تكبير",
@@ -31,7 +32,11 @@
 		"imageItem": "صورة",
 		"emptyText": "نص فارغ",
 		"cameraFullscreen": "كاميرا كاملة الشاشة",
-		"cameraFullscreenItem": "كاميرا كاملة الشاشة {{index}}"
+		"cameraFullscreenItem": "كاميرا كاملة الشاشة {{index}}",
+		"layoutScreenPip": "الشاشة + الكاميرا",
+		"layoutCameraFull": "كاميرا بملء الشاشة",
+		"layoutCameraFullPip": "كاميرا + نافذة صغيرة",
+		"layoutSideBySide": "جنبًا إلى جنب"
 	},
 	"emptyState": {
 		"noVideo": "لم يتم تحميل أي فيديو",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "لا يمكن وضع السرعة هنا",
 		"speedExistsAtLocation": "توجد منطقة سرعة بالفعل في هذا الموقع أو لا توجد مساحة كافية متاحة.",
 		"cannotPlaceCameraFullscreen": "لا يمكن وضع الكاميرا الكاملة هنا",
-		"cameraFullscreenExistsAtLocation": "يوجد بالفعل مقطع كاميرا كاملة الشاشة في هذا الموقع أو لا توجد مساحة كافية متاحة."
+		"cameraFullscreenExistsAtLocation": "يوجد بالفعل مقطع كاميرا كاملة الشاشة في هذا الموقع أو لا توجد مساحة كافية متاحة.",
+		"tooFewCameras": "يتطلب هذا التخطيط كاميرات أكثر من المتاحة هنا",
+		"cannotPlaceCameraSection": "لا يمكن وضع مقطع كاميرا هنا",
+		"cameraSectionExistsAtLocation": "يوجد مقطع كاميرا هنا بالفعل.",
+		"noCamera": "لا توجد كاميرا في هذا المشروع"
 	},
 	"success": {
 		"addedZoomSuggestions": "تمت إضافة {{count}} اقتراح تكبير بناءً على المؤشر",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "التسجيل غير متاح هنا",
 		"saveFailed": "تعذر حفظ التسجيل",
 		"importFailed": "تعذر استيراد الملف الصوتي"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "غير متاح مع إعداد التخطيط هذا",
+		"needsCamerasHint": "يتطلب كاميرات أكثر"
 	}
 }
diff --git a/src/i18n/locales/cs/dialogs.json b/src/i18n/locales/cs/dialogs.json
index 850e673c7..018bf5ffe 100644
--- a/src/i18n/locales/cs/dialogs.json
+++ b/src/i18n/locales/cs/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "Zvukové soubory",
 		"openscreenProject": "Projekt OpenScreen",
 		"allFiles": "Všechny soubory"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "Opravit perspektivu – {{camera}}",
+		"titleCrop": "Oříznout – {{camera}}",
+		"loading": "Načítání obrazu kamery…",
+		"loadFailed": "Obraz kamery se nepodařilo načíst.",
+		"perspectiveHelp": "Přetáhněte čtyři rohy na rohy listu nebo stolu. Šipky posunou vybraný roh o jeden pixel, se Shiftem o deset.",
+		"cropIgnored": "Tato kamera má ořez; dokud je nastavena perspektiva, ořez se ignoruje.",
+		"cropHelp": "Přetáhněte rámeček nebo jeho úchyty na část obrazu, která má zůstat. Šipky jej posouvají, Shift + šipky mění velikost.",
+		"corners": {
+			"topLeft": "Levý horní roh",
+			"topRight": "Pravý horní roh",
+			"bottomRight": "Pravý dolní roh",
+			"bottomLeft": "Levý dolní roh"
+		},
+		"format": "Cílový formát",
+		"formats": {
+			"a4Portrait": "A4 na výšku",
+			"a4Landscape": "A4 na šířku",
+			"free": "Volný"
+		},
+		"freeRatio": "Poměr (šířka ÷ výška)",
+		"margin": "Okraj",
+		"preview": "Náhled",
+		"loupe": "Lupa",
+		"cropArea": "Oblast ořezu",
+		"invalidQuad": "Rohy se kříží, leží na jedné přímce nebo tvoří promáčknutý (nekonvexní) tvar. Rozmístěte je do konvexního čtyřúhelníku, abyste mohli použít.",
+		"reset": "Obnovit",
+		"apply": "Použít",
+		"invalidRatio": "Zadejte poměr mezi {{min}} a {{max}}.",
+		"detectMarkers": "Rozpoznat značky",
+		"printMarkerSheet": "Vytisknout list se značkami",
+		"markersFound": "Všechny čtyři značky nalezeny; rohy byly umístěny na ně.",
+		"markersNotFound": "Nebyly nalezeny všechny čtyři značky (0–3). Zkontrolujte, že jsou celé v záběru, rovné a rovnoměrně osvětlené. Rohy zůstaly beze změny.",
+		"markerSheetInstruction": "Vystřihněte podél čar. Vnitřní roh každé značky položte na roh podle popisku."
 	}
 }
diff --git a/src/i18n/locales/cs/editor.json b/src/i18n/locales/cs/editor.json
index 78ed90f4f..16781fbaa 100644
--- a/src/i18n/locales/cs/editor.json
+++ b/src/i18n/locales/cs/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "Náhled videa",
 		"webcamPreview": "Náhled kamery",
+		"layoutPlace": "Okno kamery — přetažením přesunete",
+		"layoutPlaceResize": "Změnit velikost okna kamery",
 		"mediaError": {
 			"title": "Náhled zastaven",
 			"description": "Video nelze dekódovat. Soubor může být poškozen, stále se zapisuje nebo již není tam, kde ho projekt očekává. Váš projekt je v pořádku.",
diff --git a/src/i18n/locales/cs/settings.json b/src/i18n/locales/cs/settings.json
index c84efbd18..4cdef4145 100644
--- a/src/i18n/locales/cs/settings.json
+++ b/src/i18n/locales/cs/settings.json
@@ -462,5 +462,27 @@
 		"dark": "Tmavý",
 		"light": "Světlý",
 		"custom": "Vlastní"
+	},
+	"cameraLayout": {
+		"template": "Rozložení",
+		"placeLarge": "Místo {{n}} · velké",
+		"placeSmall": "Místo {{n}} · malé",
+		"placeLeft": "Místo {{n}} · vlevo",
+		"placeRight": "Místo {{n}} · vpravo",
+		"cameraUnavailable": "{{name}} (nedostupná)",
+		"resetWindows": "Obnovit okna"
+	},
+	"cameras": {
+		"cameraN": "Kamera {{n}}",
+		"cameraNamed": "Kamera {{n}} · {{label}}",
+		"title": "Kamery",
+		"unavailable": "Nedostupné",
+		"camera1Hint": "Otočení, zrcadlení a ořez kamery 1 jsou v ovládacích prvcích výše.",
+		"rotation": "Otočení",
+		"mirror": "Zrcadlit",
+		"crop": "Ořez…",
+		"perspective": "Opravit perspektivu…",
+		"reset": "Obnovit",
+		"cropOffWithPerspective": "Dokud je nastavena perspektiva, ořez nemá žádný účinek."
 	}
 }
diff --git a/src/i18n/locales/cs/timeline.json b/src/i18n/locales/cs/timeline.json
index 6c932b239..d375587ee 100644
--- a/src/i18n/locales/cs/timeline.json
+++ b/src/i18n/locales/cs/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "Přidat oříznutí: odstraní část videa v aktuálním čase",
 		"addAnnotation": "Přidat text, šipku, obrázek nebo rozmazání v aktuálním čase",
 		"addSpeed": "Přidat změnu rychlosti v aktuálním čase",
-		"addCameraFullscreen": "Přidat Celou kameru: zobrazí kameru na celou obrazovku v aktuálním čase"
+		"addCameraFullscreen": "Přidat Celou kameru: zobrazí kameru na celou obrazovku v aktuálním čase",
+		"addLayout": "Přidat rozvržení: uspořádání obrazovky a kamer pro úsek"
 	},
 	"hints": {
 		"pressZoom": "Stiskněte {{key}} pro přidání přiblížení",
@@ -31,7 +32,11 @@
 		"imageItem": "Obrázek",
 		"emptyText": "Prázdný text",
 		"cameraFullscreen": "Celá kamera",
-		"cameraFullscreenItem": "Celá kamera {{index}}"
+		"cameraFullscreenItem": "Celá kamera {{index}}",
+		"layoutScreenPip": "Obrazovka + kamera",
+		"layoutCameraFull": "Kamera na celou obrazovku",
+		"layoutCameraFullPip": "Kamera + vložené okno",
+		"layoutSideBySide": "Vedle sebe"
 	},
 	"emptyState": {
 		"noVideo": "Žádné video nenačteno",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "Rychlost zde nelze umístit",
 		"speedExistsAtLocation": "Oblast rychlosti na tomto místě již existuje nebo není dostatek místa.",
 		"cannotPlaceCameraFullscreen": "Celou kameru zde nelze umístit",
-		"cameraFullscreenExistsAtLocation": "Segment celé kamery na tomto místě již existuje nebo není dostatek místa."
+		"cameraFullscreenExistsAtLocation": "Segment celé kamery na tomto místě již existuje nebo není dostatek místa.",
+		"tooFewCameras": "Toto rozvržení vyžaduje více kamer, než je zde k dispozici",
+		"cannotPlaceCameraSection": "Sem nelze umístit úsek kamery",
+		"cameraSectionExistsAtLocation": "Zde už je úsek kamery.",
+		"noCamera": "Tento projekt nemá kameru"
 	},
 	"success": {
 		"addedZoomSuggestions": "Přidán {{count}} návrh přiblížení na základě kurzoru",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "Nahrávání zde není dostupné",
 		"saveFailed": "Nepodařilo se uložit nahrávku",
 		"importFailed": "Nepodařilo se importovat zvukový soubor"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "Není k dispozici s touto předvolbou rozvržení",
+		"needsCamerasHint": "Vyžaduje více kamer"
 	}
 }
diff --git a/src/i18n/locales/de/dialogs.json b/src/i18n/locales/de/dialogs.json
index 2c5e70ccd..cc458ef4a 100644
--- a/src/i18n/locales/de/dialogs.json
+++ b/src/i18n/locales/de/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "Audiodateien",
 		"openscreenProject": "OpenScreen-Projekt",
 		"allFiles": "Alle Dateien"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "Perspektive korrigieren – {{camera}}",
+		"titleCrop": "Zuschneiden – {{camera}}",
+		"loading": "Kamerabild wird geladen…",
+		"loadFailed": "Das Kamerabild konnte nicht geladen werden.",
+		"perspectiveHelp": "Ziehe die vier Ecken auf die Ecken des Blatts oder Tischs. Die Pfeiltasten verschieben die gewählte Ecke um ein Pixel, mit Umschalt um zehn.",
+		"cropIgnored": "Diese Kamera hat einen Zuschnitt; er wird ignoriert, solange eine Perspektive gesetzt ist.",
+		"cropHelp": "Ziehe den Rahmen oder seine Griffe auf den Bildteil, der bleiben soll. Die Pfeiltasten verschieben ihn, Umschalt + Pfeiltasten ändern die Größe.",
+		"corners": {
+			"topLeft": "Ecke oben links",
+			"topRight": "Ecke oben rechts",
+			"bottomRight": "Ecke unten rechts",
+			"bottomLeft": "Ecke unten links"
+		},
+		"format": "Zielformat",
+		"formats": {
+			"a4Portrait": "A4 hoch",
+			"a4Landscape": "A4 quer",
+			"free": "Frei"
+		},
+		"freeRatio": "Verhältnis (Breite ÷ Höhe)",
+		"margin": "Rand",
+		"preview": "Vorschau",
+		"loupe": "Lupe",
+		"cropArea": "Zuschnittbereich",
+		"invalidQuad": "Die Ecken überkreuzen sich, liegen auf einer Linie oder bilden eine eingedellte (nicht konvexe) Form. Ordne sie zu einem konvexen Viereck an, um zu übernehmen.",
+		"reset": "Zurücksetzen",
+		"apply": "Übernehmen",
+		"invalidRatio": "Gib ein Verhältnis zwischen {{min}} und {{max}} ein.",
+		"detectMarkers": "Marker erkennen",
+		"printMarkerSheet": "Markerblatt drucken",
+		"markersFound": "Alle vier Marker gefunden; die Ecken wurden auf sie gesetzt.",
+		"markersNotFound": "Nicht alle vier Marker (0–3) gefunden. Achte darauf, dass sie ganz im Bild, flach und gleichmäßig beleuchtet sind. Die Ecken bleiben unverändert.",
+		"markerSheetInstruction": "An den gestrichelten Linien ausschneiden. Innere Ecke jedes Markers auf seine Ecke legen."
 	}
 }
diff --git a/src/i18n/locales/de/editor.json b/src/i18n/locales/de/editor.json
index c5bc7453f..dcc85d9a5 100644
--- a/src/i18n/locales/de/editor.json
+++ b/src/i18n/locales/de/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "Videovorschau",
 		"webcamPreview": "Kameravorschau",
+		"layoutPlace": "Kamerafenster — zum Verschieben ziehen",
+		"layoutPlaceResize": "Kamerafenster skalieren",
 		"mediaError": {
 			"title": "Vorschau gestoppt",
 			"description": "Das Video konnte nicht dekodiert werden. Die Datei ist womöglich beschädigt, wird noch geschrieben oder liegt nicht mehr dort, wo das Projekt sie erwartet — dein Projekt selbst ist intakt.",
diff --git a/src/i18n/locales/de/settings.json b/src/i18n/locales/de/settings.json
index 36f57f709..a1de9ff04 100644
--- a/src/i18n/locales/de/settings.json
+++ b/src/i18n/locales/de/settings.json
@@ -462,5 +462,27 @@
 		"dark": "Dunkel",
 		"light": "Hell",
 		"custom": "Eigene"
+	},
+	"cameraLayout": {
+		"template": "Layout",
+		"placeLarge": "Platz {{n}} · groß",
+		"placeSmall": "Platz {{n}} · klein",
+		"placeLeft": "Platz {{n}} · links",
+		"placeRight": "Platz {{n}} · rechts",
+		"cameraUnavailable": "{{name}} (nicht verfügbar)",
+		"resetWindows": "Fenster zurücksetzen"
+	},
+	"cameras": {
+		"cameraN": "Kamera {{n}}",
+		"cameraNamed": "Kamera {{n}} · {{label}}",
+		"title": "Kameras",
+		"unavailable": "Nicht verfügbar",
+		"camera1Hint": "Drehung, Spiegelung und Zuschnitt von Kamera 1 stehen in den Reglern oben.",
+		"rotation": "Drehung",
+		"mirror": "Spiegeln",
+		"crop": "Zuschnitt…",
+		"perspective": "Perspektive korrigieren…",
+		"reset": "Zurücksetzen",
+		"cropOffWithPerspective": "Mit gesetzter Perspektive hat der Zuschnitt keine Wirkung."
 	}
 }
diff --git a/src/i18n/locales/de/timeline.json b/src/i18n/locales/de/timeline.json
index c2785ab43..58a277a04 100644
--- a/src/i18n/locales/de/timeline.json
+++ b/src/i18n/locales/de/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "Trim hinzufügen: entfernt einen Abschnitt des Videos zum aktuellen Zeitpunkt",
 		"addAnnotation": "Text, Pfeil, Bild oder Weichzeichner zum aktuellen Zeitpunkt hinzufügen",
 		"addSpeed": "Tempowechsel zum aktuellen Zeitpunkt hinzufügen",
-		"addCameraFullscreen": "Vollbild-Kamera hinzufügen: zeigt die Kamera im Vollbild zum aktuellen Zeitpunkt"
+		"addCameraFullscreen": "Vollbild-Kamera hinzufügen: zeigt die Kamera im Vollbild zum aktuellen Zeitpunkt",
+		"addLayout": "Layout hinzufügen: Anordnung von Bildschirm und Kameras für einen Abschnitt"
 	},
 	"hints": {
 		"pressZoom": "Drücke {{key}}, um einen Zoom hinzuzufügen",
@@ -31,7 +32,11 @@
 		"imageItem": "Bild",
 		"emptyText": "Leerer Text",
 		"cameraFullscreen": "Vollbild-Kamera",
-		"cameraFullscreenItem": "Vollbild-Kamera {{index}}"
+		"cameraFullscreenItem": "Vollbild-Kamera {{index}}",
+		"layoutScreenPip": "Bildschirm + Kamera",
+		"layoutCameraFull": "Kamera voll",
+		"layoutCameraFullPip": "Kamera + Einblendung",
+		"layoutSideBySide": "Nebeneinander"
 	},
 	"emptyState": {
 		"noVideo": "Kein Video geladen",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "Tempo kann hier nicht platziert werden",
 		"speedExistsAtLocation": "An dieser Stelle gibt es bereits einen Tempo-Bereich oder es ist nicht genug Platz.",
 		"cannotPlaceCameraFullscreen": "Vollbild-Kamera kann hier nicht platziert werden",
-		"cameraFullscreenExistsAtLocation": "An dieser Stelle gibt es bereits einen Vollbild-Kamera-Abschnitt oder es ist nicht genug Platz."
+		"cameraFullscreenExistsAtLocation": "An dieser Stelle gibt es bereits einen Vollbild-Kamera-Abschnitt oder es ist nicht genug Platz.",
+		"tooFewCameras": "Dieses Layout braucht mehr Kameras, als hier verfügbar sind",
+		"cannotPlaceCameraSection": "Hier kann kein Kamera-Abschnitt platziert werden",
+		"cameraSectionExistsAtLocation": "Hier ist bereits ein Kamera-Abschnitt.",
+		"noCamera": "Dieses Projekt hat keine Kamera"
 	},
 	"success": {
 		"addedZoomSuggestions": "{{count}} Zoom-Vorschlag aus der Cursorbewegung hinzugefügt",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "Aufnahme ist hier nicht verfügbar",
 		"saveFailed": "Die Aufnahme konnte nicht gespeichert werden",
 		"importFailed": "Die Audiodatei konnte nicht importiert werden"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "Mit diesem Layout-Preset nicht verfügbar",
+		"needsCamerasHint": "Braucht mehr Kameras"
 	}
 }
diff --git a/src/i18n/locales/en/dialogs.json b/src/i18n/locales/en/dialogs.json
index 9cd0bbbbc..d2dcd0cf2 100644
--- a/src/i18n/locales/en/dialogs.json
+++ b/src/i18n/locales/en/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "Audio files",
 		"openscreenProject": "OpenScreen project",
 		"allFiles": "All files"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "Correct perspective – {{camera}}",
+		"titleCrop": "Crop – {{camera}}",
+		"loading": "Loading the camera picture…",
+		"loadFailed": "The camera picture could not be loaded.",
+		"perspectiveHelp": "Drag the four corners onto the corners of the sheet or desk. The arrow keys move the selected corner by one pixel, with Shift by ten.",
+		"cropIgnored": "This camera has a crop; the crop is ignored while a perspective is set.",
+		"cropHelp": "Drag the frame or its handles to choose the part of the picture to keep. The arrow keys move it, Shift + arrow keys resize it.",
+		"corners": {
+			"topLeft": "Top-left corner",
+			"topRight": "Top-right corner",
+			"bottomRight": "Bottom-right corner",
+			"bottomLeft": "Bottom-left corner"
+		},
+		"format": "Target format",
+		"formats": {
+			"a4Portrait": "A4 portrait",
+			"a4Landscape": "A4 landscape",
+			"free": "Free"
+		},
+		"freeRatio": "Ratio (width ÷ height)",
+		"margin": "Margin",
+		"preview": "Preview",
+		"loupe": "Magnifier",
+		"cropArea": "Crop area",
+		"invalidQuad": "The corners cross, lie on one line or form a dented (not convex) shape. Move them into a convex four-sided shape to apply.",
+		"reset": "Reset",
+		"apply": "Apply",
+		"invalidRatio": "Enter a ratio between {{min}} and {{max}}.",
+		"detectMarkers": "Detect markers",
+		"printMarkerSheet": "Print marker sheet",
+		"markersFound": "All four markers found; the corners were placed on them.",
+		"markersNotFound": "Not all four markers (0–3) were found. Make sure they are fully in the picture, flat and evenly lit. The corners were left as they were.",
+		"markerSheetInstruction": "Cut along the dashed lines. Put each marker's inner corner on its labelled corner."
 	}
 }
diff --git a/src/i18n/locales/en/editor.json b/src/i18n/locales/en/editor.json
index 8a2073355..17d4cb851 100644
--- a/src/i18n/locales/en/editor.json
+++ b/src/i18n/locales/en/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "Video preview",
 		"webcamPreview": "Camera preview",
+		"layoutPlace": "Camera window — drag to move",
+		"layoutPlaceResize": "Resize camera window",
 		"mediaError": {
 			"title": "Preview stopped",
 			"description": "The video couldn't be decoded. The file may be damaged, still being written, or no longer where the project expects it — your project itself is intact.",
diff --git a/src/i18n/locales/en/settings.json b/src/i18n/locales/en/settings.json
index 813ce382e..5d110cc16 100644
--- a/src/i18n/locales/en/settings.json
+++ b/src/i18n/locales/en/settings.json
@@ -462,5 +462,27 @@
 		"dark": "Dark",
 		"light": "Light",
 		"custom": "Custom"
+	},
+	"cameraLayout": {
+		"template": "Layout",
+		"placeLarge": "Place {{n}} · large",
+		"placeSmall": "Place {{n}} · small",
+		"placeLeft": "Place {{n}} · left",
+		"placeRight": "Place {{n}} · right",
+		"cameraUnavailable": "{{name}} (unavailable)",
+		"resetWindows": "Reset windows"
+	},
+	"cameras": {
+		"cameraN": "Camera {{n}}",
+		"cameraNamed": "Camera {{n}} · {{label}}",
+		"title": "Cameras",
+		"unavailable": "Unavailable",
+		"camera1Hint": "Rotation, mirror and crop of camera 1 are the controls above.",
+		"rotation": "Rotation",
+		"mirror": "Mirror",
+		"crop": "Crop…",
+		"perspective": "Correct perspective…",
+		"reset": "Reset",
+		"cropOffWithPerspective": "Crop has no effect while a perspective is set."
 	}
 }
diff --git a/src/i18n/locales/en/timeline.json b/src/i18n/locales/en/timeline.json
index 33942d460..5dd023a49 100644
--- a/src/i18n/locales/en/timeline.json
+++ b/src/i18n/locales/en/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "Add a trim: removes a section of the video at the current time",
 		"addAnnotation": "Add text, an arrow, an image or a blur at the current time",
 		"addSpeed": "Add a speed change at the current time",
-		"addCameraFullscreen": "Add Full Camera: shows the camera full screen at the current time"
+		"addCameraFullscreen": "Add Full Camera: shows the camera full screen at the current time",
+		"addLayout": "Add layout: screen and camera arrangements for a section"
 	},
 	"hints": {
 		"pressZoom": "Press {{key}} to add zoom",
@@ -31,7 +32,11 @@
 		"imageItem": "Image",
 		"emptyText": "Empty text",
 		"cameraFullscreen": "Full Camera",
-		"cameraFullscreenItem": "Full Camera {{index}}"
+		"cameraFullscreenItem": "Full Camera {{index}}",
+		"layoutScreenPip": "Screen + camera",
+		"layoutCameraFull": "Full camera",
+		"layoutCameraFullPip": "Camera + inset",
+		"layoutSideBySide": "Side by side"
 	},
 	"emptyState": {
 		"noVideo": "No video loaded",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "Cannot place speed here",
 		"speedExistsAtLocation": "Speed region already exists at this location or not enough space available.",
 		"cannotPlaceCameraFullscreen": "Cannot place Full Camera here",
-		"cameraFullscreenExistsAtLocation": "A Full Camera segment already exists at this location or not enough space available."
+		"cameraFullscreenExistsAtLocation": "A Full Camera segment already exists at this location or not enough space available.",
+		"tooFewCameras": "This layout needs more cameras than are available here",
+		"cannotPlaceCameraSection": "Cannot place a camera section here",
+		"cameraSectionExistsAtLocation": "A camera section is already here.",
+		"noCamera": "This project has no camera"
 	},
 	"success": {
 		"addedZoomSuggestions": "Added {{count}} cursor-based zoom suggestion",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "Recording is not available here",
 		"saveFailed": "Could not save the recording",
 		"importFailed": "Could not import the audio file"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "Not available with this layout preset",
+		"needsCamerasHint": "Needs more cameras"
 	}
 }
diff --git a/src/i18n/locales/es/dialogs.json b/src/i18n/locales/es/dialogs.json
index 8f26a3aff..23bb680dd 100644
--- a/src/i18n/locales/es/dialogs.json
+++ b/src/i18n/locales/es/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "Archivos de audio",
 		"openscreenProject": "Proyecto OpenScreen",
 		"allFiles": "Todos los archivos"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "Corregir perspectiva – {{camera}}",
+		"titleCrop": "Recortar – {{camera}}",
+		"loading": "Cargando la imagen de la cámara…",
+		"loadFailed": "No se pudo cargar la imagen de la cámara.",
+		"perspectiveHelp": "Arrastra las cuatro esquinas a las esquinas de la hoja o del escritorio. Las flechas mueven la esquina seleccionada un píxel; con Mayús, diez.",
+		"cropIgnored": "Esta cámara tiene un recorte; se ignora mientras haya una perspectiva definida.",
+		"cropHelp": "Arrastra el marco o sus controles sobre la parte de la imagen que quieres conservar. Las flechas lo mueven; Mayús + flechas cambian su tamaño.",
+		"corners": {
+			"topLeft": "Esquina superior izquierda",
+			"topRight": "Esquina superior derecha",
+			"bottomRight": "Esquina inferior derecha",
+			"bottomLeft": "Esquina inferior izquierda"
+		},
+		"format": "Formato de destino",
+		"formats": {
+			"a4Portrait": "A4 vertical",
+			"a4Landscape": "A4 horizontal",
+			"free": "Libre"
+		},
+		"freeRatio": "Proporción (ancho ÷ alto)",
+		"margin": "Margen",
+		"preview": "Vista previa",
+		"loupe": "Lupa",
+		"cropArea": "Área de recorte",
+		"invalidQuad": "Las esquinas se cruzan, están en una misma línea o forman una figura hundida (no convexa). Colócalas formando un cuadrilátero convexo para aplicar.",
+		"reset": "Restablecer",
+		"apply": "Aplicar",
+		"invalidRatio": "Introduce una proporción entre {{min}} y {{max}}.",
+		"detectMarkers": "Detectar marcadores",
+		"printMarkerSheet": "Imprimir hoja de marcadores",
+		"markersFound": "Se encontraron los cuatro marcadores; las esquinas se colocaron sobre ellos.",
+		"markersNotFound": "No se encontraron los cuatro marcadores (0–3). Asegúrate de que estén completos en la imagen, planos y con iluminación uniforme. Las esquinas no se han cambiado.",
+		"markerSheetInstruction": "Recorta por las líneas. Pon la esquina interior de cada marcador en su esquina."
 	}
 }
diff --git a/src/i18n/locales/es/editor.json b/src/i18n/locales/es/editor.json
index 5640049e7..2a600d4da 100644
--- a/src/i18n/locales/es/editor.json
+++ b/src/i18n/locales/es/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "Vista previa del vídeo",
 		"webcamPreview": "Vista previa de la cámara",
+		"layoutPlace": "Ventana de cámara: arrastra para mover",
+		"layoutPlaceResize": "Cambiar el tamaño de la ventana de cámara",
 		"mediaError": {
 			"title": "Vista previa detenida",
 			"description": "No se pudo decodificar el vídeo. El archivo puede estar dañado, aún escribiéndose, o ya no estar donde el proyecto lo espera; tu proyecto está intacto.",
diff --git a/src/i18n/locales/es/settings.json b/src/i18n/locales/es/settings.json
index 946ec2b38..621488229 100644
--- a/src/i18n/locales/es/settings.json
+++ b/src/i18n/locales/es/settings.json
@@ -462,5 +462,27 @@
 		"dark": "Oscura",
 		"light": "Clara",
 		"custom": "Personalizada"
+	},
+	"cameraLayout": {
+		"template": "Diseño",
+		"placeLarge": "Posición {{n}} · grande",
+		"placeSmall": "Posición {{n}} · pequeña",
+		"placeLeft": "Posición {{n}} · izquierda",
+		"placeRight": "Posición {{n}} · derecha",
+		"cameraUnavailable": "{{name}} (no disponible)",
+		"resetWindows": "Restablecer ventanas"
+	},
+	"cameras": {
+		"cameraN": "Cámara {{n}}",
+		"cameraNamed": "Cámara {{n}} · {{label}}",
+		"title": "Cámaras",
+		"unavailable": "No disponible",
+		"camera1Hint": "El giro, el espejo y el recorte de la cámara 1 están en los controles de arriba.",
+		"rotation": "Giro",
+		"mirror": "Espejo",
+		"crop": "Recorte…",
+		"perspective": "Corregir perspectiva…",
+		"reset": "Restablecer",
+		"cropOffWithPerspective": "El recorte no tiene efecto mientras haya una perspectiva definida."
 	}
 }
diff --git a/src/i18n/locales/es/timeline.json b/src/i18n/locales/es/timeline.json
index e8d1e9941..4e32fd758 100644
--- a/src/i18n/locales/es/timeline.json
+++ b/src/i18n/locales/es/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "Agregar un recorte: quita una parte del video en el momento actual",
 		"addAnnotation": "Agregar texto, una flecha, una imagen o un desenfoque en el momento actual",
 		"addSpeed": "Agregar un cambio de velocidad en el momento actual",
-		"addCameraFullscreen": "Agregar Cámara a pantalla completa: muestra la cámara a pantalla completa en el momento actual"
+		"addCameraFullscreen": "Agregar Cámara a pantalla completa: muestra la cámara a pantalla completa en el momento actual",
+		"addLayout": "Añadir diseño: disposición de pantalla y cámaras para una sección"
 	},
 	"hints": {
 		"pressZoom": "Presiona {{key}} para agregar zoom",
@@ -31,7 +32,11 @@
 		"imageItem": "Imagen",
 		"emptyText": "Texto vacío",
 		"cameraFullscreen": "Cámara a pantalla completa",
-		"cameraFullscreenItem": "Cámara a pantalla completa {{index}}"
+		"cameraFullscreenItem": "Cámara a pantalla completa {{index}}",
+		"layoutScreenPip": "Pantalla + cámara",
+		"layoutCameraFull": "Cámara completa",
+		"layoutCameraFullPip": "Cámara + recuadro",
+		"layoutSideBySide": "Lado a lado"
 	},
 	"emptyState": {
 		"noVideo": "No hay video cargado",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "No se puede colocar la velocidad aquí",
 		"speedExistsAtLocation": "Ya existe una región de velocidad en esta ubicación o no hay suficiente espacio disponible.",
 		"cannotPlaceCameraFullscreen": "No se puede colocar la cámara a pantalla completa aquí",
-		"cameraFullscreenExistsAtLocation": "Ya existe un segmento de cámara a pantalla completa en esta ubicación o no hay suficiente espacio disponible."
+		"cameraFullscreenExistsAtLocation": "Ya existe un segmento de cámara a pantalla completa en esta ubicación o no hay suficiente espacio disponible.",
+		"tooFewCameras": "Este diseño necesita más cámaras de las disponibles aquí",
+		"cannotPlaceCameraSection": "No se puede colocar una sección de cámara aquí",
+		"cameraSectionExistsAtLocation": "Ya hay una sección de cámara aquí.",
+		"noCamera": "Este proyecto no tiene cámara"
 	},
 	"success": {
 		"addedZoomSuggestions": "Se agregó {{count}} sugerencia de zoom basada en el cursor",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "La grabación no está disponible aquí",
 		"saveFailed": "No se pudo guardar la grabación",
 		"importFailed": "No se pudo importar el archivo de audio"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "No disponible con este ajuste de diseño",
+		"needsCamerasHint": "Necesita más cámaras"
 	}
 }
diff --git a/src/i18n/locales/fr/dialogs.json b/src/i18n/locales/fr/dialogs.json
index ad5b4edf6..193ea7b50 100644
--- a/src/i18n/locales/fr/dialogs.json
+++ b/src/i18n/locales/fr/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "Fichiers audio",
 		"openscreenProject": "Projet OpenScreen",
 		"allFiles": "Tous les fichiers"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "Corriger la perspective – {{camera}}",
+		"titleCrop": "Recadrer – {{camera}}",
+		"loading": "Chargement de l'image de la caméra…",
+		"loadFailed": "Impossible de charger l'image de la caméra.",
+		"perspectiveHelp": "Faites glisser les quatre coins sur ceux de la feuille ou du bureau. Les flèches déplacent le coin choisi d'un pixel, de dix avec Maj.",
+		"cropIgnored": "Cette caméra a un recadrage ; il est ignoré tant qu'une perspective est définie.",
+		"cropHelp": "Faites glisser le cadre ou ses poignées sur la partie de l'image à garder. Les flèches le déplacent, Maj + flèches le redimensionnent.",
+		"corners": {
+			"topLeft": "Coin supérieur gauche",
+			"topRight": "Coin supérieur droit",
+			"bottomRight": "Coin inférieur droit",
+			"bottomLeft": "Coin inférieur gauche"
+		},
+		"format": "Format cible",
+		"formats": {
+			"a4Portrait": "A4 portrait",
+			"a4Landscape": "A4 paysage",
+			"free": "Libre"
+		},
+		"freeRatio": "Rapport (largeur ÷ hauteur)",
+		"margin": "Marge",
+		"preview": "Aperçu",
+		"loupe": "Loupe",
+		"cropArea": "Zone de recadrage",
+		"invalidQuad": "Les coins se croisent, sont alignés ou forment une figure rentrante (non convexe). Disposez-les en quadrilatère convexe pour appliquer.",
+		"reset": "Réinitialiser",
+		"apply": "Appliquer",
+		"invalidRatio": "Saisissez un rapport entre {{min}} et {{max}}.",
+		"detectMarkers": "Détecter les marqueurs",
+		"printMarkerSheet": "Imprimer la feuille de marqueurs",
+		"markersFound": "Les quatre marqueurs ont été trouvés ; les coins y ont été placés.",
+		"markersNotFound": "Les quatre marqueurs (0–3) n’ont pas tous été trouvés. Vérifiez qu’ils sont entièrement dans l’image, à plat et éclairés uniformément. Les coins n’ont pas été modifiés.",
+		"markerSheetInstruction": "Découpez selon les pointillés. Posez le coin intérieur de chaque marqueur sur son coin."
 	}
 }
diff --git a/src/i18n/locales/fr/editor.json b/src/i18n/locales/fr/editor.json
index e7e0c5bf2..b5db838fc 100644
--- a/src/i18n/locales/fr/editor.json
+++ b/src/i18n/locales/fr/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "Aperçu vidéo",
 		"webcamPreview": "Aperçu de la caméra",
+		"layoutPlace": "Fenêtre de caméra — faire glisser pour déplacer",
+		"layoutPlaceResize": "Redimensionner la fenêtre de caméra",
 		"mediaError": {
 			"title": "Aperçu interrompu",
 			"description": "La vidéo n'a pas pu être décodée. Le fichier est peut-être endommagé, en cours d'écriture, ou plus à l'emplacement attendu — votre projet, lui, est intact.",
diff --git a/src/i18n/locales/fr/settings.json b/src/i18n/locales/fr/settings.json
index dbcc91c15..5f3fe4d9a 100644
--- a/src/i18n/locales/fr/settings.json
+++ b/src/i18n/locales/fr/settings.json
@@ -462,5 +462,27 @@
 		"dark": "Sombre",
 		"light": "Claire",
 		"custom": "Personnalisée"
+	},
+	"cameraLayout": {
+		"template": "Disposition",
+		"placeLarge": "Emplacement {{n}} · grand",
+		"placeSmall": "Emplacement {{n}} · petit",
+		"placeLeft": "Emplacement {{n}} · gauche",
+		"placeRight": "Emplacement {{n}} · droite",
+		"cameraUnavailable": "{{name}} (indisponible)",
+		"resetWindows": "Réinitialiser les fenêtres"
+	},
+	"cameras": {
+		"cameraN": "Caméra {{n}}",
+		"cameraNamed": "Caméra {{n}} · {{label}}",
+		"title": "Caméras",
+		"unavailable": "Indisponible",
+		"camera1Hint": "La rotation, le miroir et le recadrage de la caméra 1 sont dans les réglages ci-dessus.",
+		"rotation": "Rotation",
+		"mirror": "Miroir",
+		"crop": "Recadrage…",
+		"perspective": "Corriger la perspective…",
+		"reset": "Réinitialiser",
+		"cropOffWithPerspective": "Le recadrage est sans effet tant qu'une perspective est définie."
 	}
 }
diff --git a/src/i18n/locales/fr/timeline.json b/src/i18n/locales/fr/timeline.json
index 009044900..0913cb137 100644
--- a/src/i18n/locales/fr/timeline.json
+++ b/src/i18n/locales/fr/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "Ajouter une coupe : retire une partie de la vidéo à l'instant actuel",
 		"addAnnotation": "Ajouter du texte, une flèche, une image ou un flou à l'instant actuel",
 		"addSpeed": "Ajouter un changement de vitesse à l'instant actuel",
-		"addCameraFullscreen": "Ajouter Caméra plein écran : affiche la caméra en plein écran à l'instant actuel"
+		"addCameraFullscreen": "Ajouter Caméra plein écran : affiche la caméra en plein écran à l'instant actuel",
+		"addLayout": "Ajouter une disposition : agencement de l'écran et des caméras pour une section"
 	},
 	"hints": {
 		"pressZoom": "Appuyez sur {{key}} pour ajouter un zoom",
@@ -31,7 +32,11 @@
 		"imageItem": "Image",
 		"emptyText": "Texte vide",
 		"cameraFullscreen": "Caméra plein écran",
-		"cameraFullscreenItem": "Caméra plein écran {{index}}"
+		"cameraFullscreenItem": "Caméra plein écran {{index}}",
+		"layoutScreenPip": "Écran + caméra",
+		"layoutCameraFull": "Caméra plein écran",
+		"layoutCameraFullPip": "Caméra + incrustation",
+		"layoutSideBySide": "Côte à côte"
 	},
 	"emptyState": {
 		"noVideo": "Aucune vidéo chargée",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "Impossible de placer la vitesse ici",
 		"speedExistsAtLocation": "Une région de vitesse existe déjà à cet emplacement ou l'espace disponible est insuffisant.",
 		"cannotPlaceCameraFullscreen": "Impossible de placer la caméra plein écran ici",
-		"cameraFullscreenExistsAtLocation": "Un segment Caméra plein écran existe déjà à cet emplacement ou l'espace disponible est insuffisant."
+		"cameraFullscreenExistsAtLocation": "Un segment Caméra plein écran existe déjà à cet emplacement ou l'espace disponible est insuffisant.",
+		"tooFewCameras": "Cette disposition nécessite plus de caméras que celles disponibles ici",
+		"cannotPlaceCameraSection": "Impossible de placer une section caméra ici",
+		"cameraSectionExistsAtLocation": "Une section caméra se trouve déjà ici.",
+		"noCamera": "Ce projet n'a pas de caméra"
 	},
 	"success": {
 		"addedZoomSuggestions": "{{count}} suggestion de zoom basée sur le curseur ajoutée",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "L'enregistrement n'est pas disponible ici",
 		"saveFailed": "Impossible d'enregistrer la capture",
 		"importFailed": "Impossible d'importer le fichier audio"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "Indisponible avec ce préréglage de mise en page",
+		"needsCamerasHint": "Nécessite plus de caméras"
 	}
 }
diff --git a/src/i18n/locales/it/dialogs.json b/src/i18n/locales/it/dialogs.json
index e8e326c91..dd78a4090 100644
--- a/src/i18n/locales/it/dialogs.json
+++ b/src/i18n/locales/it/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "File audio",
 		"openscreenProject": "Progetto OpenScreen",
 		"allFiles": "Tutti i file"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "Correggi prospettiva – {{camera}}",
+		"titleCrop": "Ritaglia – {{camera}}",
+		"loading": "Caricamento dell'immagine della videocamera…",
+		"loadFailed": "Impossibile caricare l'immagine della videocamera.",
+		"perspectiveHelp": "Trascina i quattro angoli sugli angoli del foglio o della scrivania. I tasti freccia spostano l'angolo selezionato di un pixel, con Maiusc di dieci.",
+		"cropIgnored": "Questa videocamera ha un ritaglio; viene ignorato finché è impostata una prospettiva.",
+		"cropHelp": "Trascina il riquadro o le sue maniglie sulla parte dell'immagine da tenere. Le frecce lo spostano, Maiusc + frecce lo ridimensionano.",
+		"corners": {
+			"topLeft": "Angolo in alto a sinistra",
+			"topRight": "Angolo in alto a destra",
+			"bottomRight": "Angolo in basso a destra",
+			"bottomLeft": "Angolo in basso a sinistra"
+		},
+		"format": "Formato di destinazione",
+		"formats": {
+			"a4Portrait": "A4 verticale",
+			"a4Landscape": "A4 orizzontale",
+			"free": "Libero"
+		},
+		"freeRatio": "Rapporto (larghezza ÷ altezza)",
+		"margin": "Margine",
+		"preview": "Anteprima",
+		"loupe": "Lente",
+		"cropArea": "Area di ritaglio",
+		"invalidQuad": "Gli angoli si incrociano, sono allineati o formano una figura rientrante (non convessa). Disponili a formare un quadrilatero convesso per applicare.",
+		"reset": "Ripristina",
+		"apply": "Applica",
+		"invalidRatio": "Inserisci un rapporto compreso tra {{min}} e {{max}}.",
+		"detectMarkers": "Rileva marcatori",
+		"printMarkerSheet": "Stampa foglio marcatori",
+		"markersFound": "Trovati tutti e quattro i marcatori; gli angoli sono stati posizionati su di essi.",
+		"markersNotFound": "Non sono stati trovati tutti e quattro i marcatori (0–3). Assicurati che siano interamente nell’immagine, piatti e illuminati in modo uniforme. Gli angoli non sono stati modificati.",
+		"markerSheetInstruction": "Ritaglia lungo le linee. Metti l’angolo interno di ogni marcatore sul suo angolo."
 	}
 }
diff --git a/src/i18n/locales/it/editor.json b/src/i18n/locales/it/editor.json
index cc2116ea3..bbc28b5b5 100644
--- a/src/i18n/locales/it/editor.json
+++ b/src/i18n/locales/it/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "Anteprima video",
 		"webcamPreview": "Anteprima fotocamera",
+		"layoutPlace": "Finestra della fotocamera — trascina per spostare",
+		"layoutPlaceResize": "Ridimensiona la finestra della fotocamera",
 		"mediaError": {
 			"title": "Anteprima interrotta",
 			"description": "Non è stato possibile decodificare il video. Il file potrebbe essere danneggiato, ancora in scrittura o non più dove il progetto lo cerca: il progetto è intatto.",
diff --git a/src/i18n/locales/it/settings.json b/src/i18n/locales/it/settings.json
index 873fbf75d..916aa9f4e 100644
--- a/src/i18n/locales/it/settings.json
+++ b/src/i18n/locales/it/settings.json
@@ -462,5 +462,27 @@
 		"dark": "Scura",
 		"light": "Chiara",
 		"custom": "Personalizzata"
+	},
+	"cameraLayout": {
+		"template": "Layout",
+		"placeLarge": "Posizione {{n}} · grande",
+		"placeSmall": "Posizione {{n}} · piccola",
+		"placeLeft": "Posizione {{n}} · sinistra",
+		"placeRight": "Posizione {{n}} · destra",
+		"cameraUnavailable": "{{name}} (non disponibile)",
+		"resetWindows": "Reimposta finestre"
+	},
+	"cameras": {
+		"cameraN": "Fotocamera {{n}}",
+		"cameraNamed": "Fotocamera {{n}} · {{label}}",
+		"title": "Fotocamere",
+		"unavailable": "Non disponibile",
+		"camera1Hint": "Rotazione, specchio e ritaglio della fotocamera 1 sono nei controlli qui sopra.",
+		"rotation": "Rotazione",
+		"mirror": "Specchio",
+		"crop": "Ritaglio…",
+		"perspective": "Correggi prospettiva…",
+		"reset": "Ripristina",
+		"cropOffWithPerspective": "Il ritaglio non ha effetto finché è impostata una prospettiva."
 	}
 }
diff --git a/src/i18n/locales/it/timeline.json b/src/i18n/locales/it/timeline.json
index ea795c464..45d9e36e3 100644
--- a/src/i18n/locales/it/timeline.json
+++ b/src/i18n/locales/it/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "Aggiungi un taglio: rimuove una parte del video nel momento attuale",
 		"addAnnotation": "Aggiungi testo, una freccia, un'immagine o una sfocatura nel momento attuale",
 		"addSpeed": "Aggiungi un cambio di velocità nel momento attuale",
-		"addCameraFullscreen": "Aggiungi Camera a schermo intero: mostra la fotocamera a schermo intero nel momento attuale"
+		"addCameraFullscreen": "Aggiungi Camera a schermo intero: mostra la fotocamera a schermo intero nel momento attuale",
+		"addLayout": "Aggiungi layout: disposizione di schermo e fotocamere per una sezione"
 	},
 	"hints": {
 		"pressZoom": "Premi {{key}} per aggiungere zoom",
@@ -31,7 +32,11 @@
 		"imageItem": "Immagine",
 		"emptyText": "Testo vuoto",
 		"cameraFullscreen": "Camera a schermo intero",
-		"cameraFullscreenItem": "Camera a schermo intero {{index}}"
+		"cameraFullscreenItem": "Camera a schermo intero {{index}}",
+		"layoutScreenPip": "Schermo + fotocamera",
+		"layoutCameraFull": "Fotocamera a schermo intero",
+		"layoutCameraFullPip": "Fotocamera + riquadro",
+		"layoutSideBySide": "Affiancati"
 	},
 	"emptyState": {
 		"noVideo": "Nessun video caricato",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "Impossibile posizionare la velocità qui",
 		"speedExistsAtLocation": "La regione velocità esiste già in questa posizione o non c'è spazio sufficiente.",
 		"cannotPlaceCameraFullscreen": "Impossibile posizionare la Camera a schermo intero qui",
-		"cameraFullscreenExistsAtLocation": "Un segmento Camera a schermo intero esiste già in questa posizione o non c'è spazio sufficiente."
+		"cameraFullscreenExistsAtLocation": "Un segmento Camera a schermo intero esiste già in questa posizione o non c'è spazio sufficiente.",
+		"tooFewCameras": "Questo layout richiede più fotocamere di quelle disponibili qui",
+		"cannotPlaceCameraSection": "Impossibile inserire qui una sezione videocamera",
+		"cameraSectionExistsAtLocation": "Qui c'è già una sezione videocamera.",
+		"noCamera": "Questo progetto non ha una fotocamera"
 	},
 	"success": {
 		"addedZoomSuggestions": "Aggiunto {{count}} suggerimento zoom basato sul cursore",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "La registrazione non è disponibile qui",
 		"saveFailed": "Impossibile salvare la registrazione",
 		"importFailed": "Impossibile importare il file audio"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "Non disponibile con questo preset di layout",
+		"needsCamerasHint": "Servono più fotocamere"
 	}
 }
diff --git a/src/i18n/locales/ja-JP/dialogs.json b/src/i18n/locales/ja-JP/dialogs.json
index c0c00ad80..a2e807a3c 100644
--- a/src/i18n/locales/ja-JP/dialogs.json
+++ b/src/i18n/locales/ja-JP/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "オーディオファイル",
 		"openscreenProject": "OpenScreen プロジェクト",
 		"allFiles": "すべてのファイル"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "遠近補正 – {{camera}}",
+		"titleCrop": "トリミング – {{camera}}",
+		"loading": "カメラ画像を読み込み中…",
+		"loadFailed": "カメラ画像を読み込めませんでした。",
+		"perspectiveHelp": "4 つの角を用紙や机の角までドラッグします。矢印キーで選択中の角を 1 ピクセル、Shift キーを押しながらで 10 ピクセル動かします。",
+		"cropIgnored": "このカメラには切り抜きがあります。遠近補正が設定されている間、切り抜きは無視されます。",
+		"cropHelp": "枠またはハンドルを、残したい部分までドラッグします。矢印キーで移動、Shift + 矢印キーでサイズを変更します。",
+		"corners": {
+			"topLeft": "左上の角",
+			"topRight": "右上の角",
+			"bottomRight": "右下の角",
+			"bottomLeft": "左下の角"
+		},
+		"format": "出力形式",
+		"formats": {
+			"a4Portrait": "A4 縦",
+			"a4Landscape": "A4 横",
+			"free": "自由"
+		},
+		"freeRatio": "比率（幅 ÷ 高さ）",
+		"margin": "余白",
+		"preview": "プレビュー",
+		"loupe": "ルーペ",
+		"cropArea": "トリミング範囲",
+		"invalidQuad": "角が交差している、一直線上にある、またはへこんだ（凸でない）形になっています。適用するには凸の四角形になるように配置してください。",
+		"reset": "リセット",
+		"apply": "適用",
+		"invalidRatio": "{{min}}～{{max}} の比率を入力してください。",
+		"detectMarkers": "マーカーを検出",
+		"printMarkerSheet": "マーカーシートを印刷",
+		"markersFound": "4 つのマーカーがすべて見つかり、角をその位置に合わせました。",
+		"markersNotFound": "4 つのマーカー（0～3）をすべて見つけられませんでした。マーカー全体が映っていて、平らで、均一に照らされているか確認してください。角は変更されていません。",
+		"markerSheetInstruction": "破線で切り取り、各マーカーの内側の角を表示された角に合わせます。"
 	}
 }
diff --git a/src/i18n/locales/ja-JP/editor.json b/src/i18n/locales/ja-JP/editor.json
index 2313587b6..3321b9eec 100644
--- a/src/i18n/locales/ja-JP/editor.json
+++ b/src/i18n/locales/ja-JP/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "動画プレビュー",
 		"webcamPreview": "カメラのプレビュー",
+		"layoutPlace": "カメラウィンドウ — ドラッグして移動",
+		"layoutPlaceResize": "カメラウィンドウのサイズを変更",
 		"mediaError": {
 			"title": "プレビューを停止しました",
 			"description": "動画をデコードできませんでした。ファイルが破損しているか、まだ書き込み中か、プロジェクトが参照している場所にない可能性があります。プロジェクト自体は損なわれていません。",
diff --git a/src/i18n/locales/ja-JP/settings.json b/src/i18n/locales/ja-JP/settings.json
index 91c65bd9f..78895a329 100644
--- a/src/i18n/locales/ja-JP/settings.json
+++ b/src/i18n/locales/ja-JP/settings.json
@@ -462,5 +462,27 @@
 		"dark": "ダーク",
 		"light": "ライト",
 		"custom": "カスタム"
+	},
+	"cameraLayout": {
+		"template": "レイアウト",
+		"placeLarge": "配置 {{n}}・大",
+		"placeSmall": "配置 {{n}}・小",
+		"placeLeft": "配置 {{n}}・左",
+		"placeRight": "配置 {{n}}・右",
+		"cameraUnavailable": "{{name}}（利用不可）",
+		"resetWindows": "ウィンドウをリセット"
+	},
+	"cameras": {
+		"cameraN": "カメラ {{n}}",
+		"cameraNamed": "カメラ {{n}} · {{label}}",
+		"title": "カメラ",
+		"unavailable": "利用できません",
+		"camera1Hint": "カメラ1の回転・反転・切り抜きは上のコントロールで設定します。",
+		"rotation": "回転",
+		"mirror": "反転",
+		"crop": "切り抜き…",
+		"perspective": "パースを補正…",
+		"reset": "リセット",
+		"cropOffWithPerspective": "遠近補正が設定されている間、切り抜きは効果がありません。"
 	}
 }
diff --git a/src/i18n/locales/ja-JP/timeline.json b/src/i18n/locales/ja-JP/timeline.json
index 81a87ffb6..a00773858 100644
--- a/src/i18n/locales/ja-JP/timeline.json
+++ b/src/i18n/locales/ja-JP/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "トリムを追加：現在の再生位置で動画の一部を削除します",
 		"addAnnotation": "現在の再生位置にテキスト、矢印、画像、ぼかしを追加",
 		"addSpeed": "現在の再生位置に再生速度の変更を追加",
-		"addCameraFullscreen": "フルスクリーンカメラを追加：現在の再生位置でカメラを全画面表示します"
+		"addCameraFullscreen": "フルスクリーンカメラを追加：現在の再生位置でカメラを全画面表示します",
+		"addLayout": "レイアウトを追加：区間の画面とカメラの配置"
 	},
 	"hints": {
 		"pressZoom": "{{key}}キーを押してズームを追加",
@@ -31,7 +32,11 @@
 		"imageItem": "画像",
 		"emptyText": "空のテキスト",
 		"cameraFullscreen": "フルスクリーンカメラ",
-		"cameraFullscreenItem": "フルスクリーンカメラ {{index}}"
+		"cameraFullscreenItem": "フルスクリーンカメラ {{index}}",
+		"layoutScreenPip": "画面 + カメラ",
+		"layoutCameraFull": "カメラ全画面",
+		"layoutCameraFullPip": "カメラ + 小窓",
+		"layoutSideBySide": "左右に並べる"
 	},
 	"emptyState": {
 		"noVideo": "ビデオが読み込まれていません",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "ここに再生速度を配置できません",
 		"speedExistsAtLocation": "この場所にはすでに再生速度の範囲が存在するか、十分なスペースがありません。",
 		"cannotPlaceCameraFullscreen": "ここにフルスクリーンカメラを配置できません",
-		"cameraFullscreenExistsAtLocation": "この場所にはすでにフルスクリーンカメラのセグメントが存在するか、十分なスペースがありません。"
+		"cameraFullscreenExistsAtLocation": "この場所にはすでにフルスクリーンカメラのセグメントが存在するか、十分なスペースがありません。",
+		"tooFewCameras": "このレイアウトには、ここで利用できる数より多くのカメラが必要です",
+		"cannotPlaceCameraSection": "ここにはカメラ区間を配置できません",
+		"cameraSectionExistsAtLocation": "ここにはすでにカメラ区間があります。",
+		"noCamera": "このプロジェクトにはカメラがありません"
 	},
 	"success": {
 		"addedZoomSuggestions": "カーソルに基づくズーム提案を {{count}} 件追加しました",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "ここでは録音できません",
 		"saveFailed": "録音を保存できませんでした",
 		"importFailed": "音声ファイルを読み込めませんでした"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "このレイアウトプリセットでは使用できません",
+		"needsCamerasHint": "カメラがさらに必要です"
 	}
 }
diff --git a/src/i18n/locales/ko-KR/dialogs.json b/src/i18n/locales/ko-KR/dialogs.json
index 2b64240ae..c0616168b 100644
--- a/src/i18n/locales/ko-KR/dialogs.json
+++ b/src/i18n/locales/ko-KR/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "오디오 파일",
 		"openscreenProject": "OpenScreen 프로젝트",
 		"allFiles": "모든 파일"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "원근 보정 – {{camera}}",
+		"titleCrop": "자르기 – {{camera}}",
+		"loading": "카메라 이미지를 불러오는 중…",
+		"loadFailed": "카메라 이미지를 불러올 수 없습니다.",
+		"perspectiveHelp": "네 모서리를 종이나 책상의 모서리로 끌어 놓으세요. 화살표 키는 선택한 모서리를 1픽셀, Shift를 누르면 10픽셀 이동합니다.",
+		"cropIgnored": "이 카메라에는 자르기가 있습니다. 원근 보정이 설정되어 있는 동안에는 자르기가 무시됩니다.",
+		"cropHelp": "프레임이나 핸들을 남길 부분으로 끌어 놓으세요. 화살표 키로 이동하고, Shift + 화살표 키로 크기를 조절합니다.",
+		"corners": {
+			"topLeft": "왼쪽 위 모서리",
+			"topRight": "오른쪽 위 모서리",
+			"bottomRight": "오른쪽 아래 모서리",
+			"bottomLeft": "왼쪽 아래 모서리"
+		},
+		"format": "대상 형식",
+		"formats": {
+			"a4Portrait": "A4 세로",
+			"a4Landscape": "A4 가로",
+			"free": "자유"
+		},
+		"freeRatio": "비율 (너비 ÷ 높이)",
+		"margin": "여백",
+		"preview": "미리 보기",
+		"loupe": "돋보기",
+		"cropArea": "자르기 영역",
+		"invalidQuad": "모서리가 교차하거나 한 직선 위에 있거나 오목한(볼록하지 않은) 모양입니다. 적용하려면 볼록한 사각형이 되도록 배치하세요.",
+		"reset": "초기화",
+		"apply": "적용",
+		"invalidRatio": "{{min}}에서 {{max}} 사이의 비율을 입력하세요.",
+		"detectMarkers": "마커 감지",
+		"printMarkerSheet": "마커 시트 인쇄",
+		"markersFound": "네 개의 마커를 모두 찾아 모서리를 마커에 맞췄습니다.",
+		"markersNotFound": "네 개의 마커(0–3)를 모두 찾지 못했습니다. 마커가 화면에 완전히 들어오고, 평평하며, 고르게 조명되는지 확인하세요. 모서리는 그대로 유지되었습니다.",
+		"markerSheetInstruction": "점선을 따라 자르고, 각 마커의 안쪽 모서리를 표시된 모서리에 맞추세요."
 	}
 }
diff --git a/src/i18n/locales/ko-KR/editor.json b/src/i18n/locales/ko-KR/editor.json
index b75059aa3..a7d413512 100644
--- a/src/i18n/locales/ko-KR/editor.json
+++ b/src/i18n/locales/ko-KR/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "영상 미리보기",
 		"webcamPreview": "카메라 미리보기",
+		"layoutPlace": "카메라 창 — 드래그하여 이동",
+		"layoutPlaceResize": "카메라 창 크기 조절",
 		"mediaError": {
 			"title": "미리보기가 중단되었습니다",
 			"description": "영상을 디코딩할 수 없습니다. 파일이 손상되었거나, 아직 저장 중이거나, 프로젝트가 기대한 위치에 없을 수 있습니다. 프로젝트 자체는 그대로입니다.",
diff --git a/src/i18n/locales/ko-KR/settings.json b/src/i18n/locales/ko-KR/settings.json
index 9e25cb89c..8a4a6b9b3 100644
--- a/src/i18n/locales/ko-KR/settings.json
+++ b/src/i18n/locales/ko-KR/settings.json
@@ -462,5 +462,27 @@
 		"dark": "어둡게",
 		"light": "밝게",
 		"custom": "사용자 지정"
+	},
+	"cameraLayout": {
+		"template": "레이아웃",
+		"placeLarge": "자리 {{n}} · 큼",
+		"placeSmall": "자리 {{n}} · 작음",
+		"placeLeft": "자리 {{n}} · 왼쪽",
+		"placeRight": "자리 {{n}} · 오른쪽",
+		"cameraUnavailable": "{{name}} (사용할 수 없음)",
+		"resetWindows": "창 재설정"
+	},
+	"cameras": {
+		"cameraN": "카메라 {{n}}",
+		"cameraNamed": "카메라 {{n}} · {{label}}",
+		"title": "카메라",
+		"unavailable": "사용할 수 없음",
+		"camera1Hint": "카메라 1의 회전, 좌우 반전, 자르기는 위의 컨트롤에서 설정합니다.",
+		"rotation": "회전",
+		"mirror": "좌우 반전",
+		"crop": "자르기…",
+		"perspective": "원근 보정…",
+		"reset": "초기화",
+		"cropOffWithPerspective": "원근 보정이 설정되어 있는 동안에는 자르기가 적용되지 않습니다."
 	}
 }
diff --git a/src/i18n/locales/ko-KR/timeline.json b/src/i18n/locales/ko-KR/timeline.json
index b97397ceb..da4f8fa97 100644
--- a/src/i18n/locales/ko-KR/timeline.json
+++ b/src/i18n/locales/ko-KR/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "트림 추가: 현재 시점에서 영상의 한 구간을 제거합니다",
 		"addAnnotation": "현재 시점에 텍스트, 화살표, 이미지 또는 블러 추가",
 		"addSpeed": "현재 시점에 속도 변경 추가",
-		"addCameraFullscreen": "전체 화면 카메라 추가: 현재 시점에 카메라를 전체 화면으로 표시합니다"
+		"addCameraFullscreen": "전체 화면 카메라 추가: 현재 시점에 카메라를 전체 화면으로 표시합니다",
+		"addLayout": "레이아웃 추가: 구간의 화면과 카메라 배치"
 	},
 	"hints": {
 		"pressZoom": "{{key}}를 눌러 줌 추가",
@@ -31,7 +32,11 @@
 		"imageItem": "이미지",
 		"emptyText": "빈 텍스트",
 		"cameraFullscreen": "전체 화면 카메라",
-		"cameraFullscreenItem": "전체 화면 카메라 {{index}}"
+		"cameraFullscreenItem": "전체 화면 카메라 {{index}}",
+		"layoutScreenPip": "화면 + 카메라",
+		"layoutCameraFull": "카메라 전체 화면",
+		"layoutCameraFullPip": "카메라 + 작은 창",
+		"layoutSideBySide": "나란히"
 	},
 	"emptyState": {
 		"noVideo": "불러온 비디오 없음",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "이 위치에 속도를 추가할 수 없습니다",
 		"speedExistsAtLocation": "이 위치에 이미 속도 구간이 있거나 공간이 부족합니다.",
 		"cannotPlaceCameraFullscreen": "이 위치에 전체 화면 카메라를 추가할 수 없습니다",
-		"cameraFullscreenExistsAtLocation": "이 위치에 이미 전체 화면 카메라 구간이 있거나 공간이 부족합니다."
+		"cameraFullscreenExistsAtLocation": "이 위치에 이미 전체 화면 카메라 구간이 있거나 공간이 부족합니다.",
+		"tooFewCameras": "이 레이아웃에는 여기서 사용할 수 있는 것보다 많은 카메라가 필요합니다",
+		"cannotPlaceCameraSection": "여기에는 카메라 구간을 배치할 수 없습니다",
+		"cameraSectionExistsAtLocation": "여기에는 이미 카메라 구간이 있습니다.",
+		"noCamera": "이 프로젝트에는 카메라가 없습니다"
 	},
 	"success": {
 		"addedZoomSuggestions": "커서 기반 줌 제안 {{count}}개가 추가되었습니다",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "여기에서는 녹음할 수 없습니다",
 		"saveFailed": "녹음을 저장하지 못했습니다",
 		"importFailed": "오디오 파일을 가져오지 못했습니다"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "이 레이아웃 프리셋에서는 사용할 수 없음",
+		"needsCamerasHint": "카메라가 더 필요합니다"
 	}
 }
diff --git a/src/i18n/locales/pt-BR/dialogs.json b/src/i18n/locales/pt-BR/dialogs.json
index 88f163d99..26b992b82 100644
--- a/src/i18n/locales/pt-BR/dialogs.json
+++ b/src/i18n/locales/pt-BR/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "Arquivos de áudio",
 		"openscreenProject": "Projeto OpenScreen",
 		"allFiles": "Todos os Arquivos"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "Corrigir perspectiva – {{camera}}",
+		"titleCrop": "Recortar – {{camera}}",
+		"loading": "Carregando a imagem da câmera…",
+		"loadFailed": "Não foi possível carregar a imagem da câmera.",
+		"perspectiveHelp": "Arraste os quatro cantos até os cantos da folha ou da mesa. As setas movem o canto selecionado um pixel; com Shift, dez.",
+		"cropIgnored": "Esta câmera tem um recorte; ele é ignorado enquanto houver uma perspectiva definida.",
+		"cropHelp": "Arraste o quadro ou suas alças sobre a parte da imagem a manter. As setas o movem; Shift + setas o redimensionam.",
+		"corners": {
+			"topLeft": "Canto superior esquerdo",
+			"topRight": "Canto superior direito",
+			"bottomRight": "Canto inferior direito",
+			"bottomLeft": "Canto inferior esquerdo"
+		},
+		"format": "Formato de destino",
+		"formats": {
+			"a4Portrait": "A4 retrato",
+			"a4Landscape": "A4 paisagem",
+			"free": "Livre"
+		},
+		"freeRatio": "Proporção (largura ÷ altura)",
+		"margin": "Margem",
+		"preview": "Prévia",
+		"loupe": "Lupa",
+		"cropArea": "Área de recorte",
+		"invalidQuad": "Os cantos se cruzam, estão alinhados ou formam uma figura reentrante (não convexa). Posicione-os formando um quadrilátero convexo para aplicar.",
+		"reset": "Redefinir",
+		"apply": "Aplicar",
+		"invalidRatio": "Insira uma proporção entre {{min}} e {{max}}.",
+		"detectMarkers": "Detectar marcadores",
+		"printMarkerSheet": "Imprimir folha de marcadores",
+		"markersFound": "Os quatro marcadores foram encontrados; os cantos foram posicionados sobre eles.",
+		"markersNotFound": "Nem todos os quatro marcadores (0–3) foram encontrados. Verifique se estão inteiros na imagem, planos e com iluminação uniforme. Os cantos não foram alterados.",
+		"markerSheetInstruction": "Recorte nas linhas. Ponha o canto interno de cada marcador no seu canto."
 	}
 }
diff --git a/src/i18n/locales/pt-BR/editor.json b/src/i18n/locales/pt-BR/editor.json
index 003ea563a..49503b945 100644
--- a/src/i18n/locales/pt-BR/editor.json
+++ b/src/i18n/locales/pt-BR/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "Pré-visualização do vídeo",
 		"webcamPreview": "Pré-visualização da câmera",
+		"layoutPlace": "Janela da câmera — arraste para mover",
+		"layoutPlaceResize": "Redimensionar a janela da câmera",
 		"mediaError": {
 			"title": "Pré-visualização interrompida",
 			"description": "Não foi possível decodificar o vídeo. O arquivo pode estar danificado, ainda sendo gravado ou não estar mais onde o projeto espera — seu projeto continua intacto.",
diff --git a/src/i18n/locales/pt-BR/settings.json b/src/i18n/locales/pt-BR/settings.json
index 87480ebd8..5957943b6 100644
--- a/src/i18n/locales/pt-BR/settings.json
+++ b/src/i18n/locales/pt-BR/settings.json
@@ -462,5 +462,27 @@
 		"dark": "Escura",
 		"light": "Clara",
 		"custom": "Personalizada"
+	},
+	"cameraLayout": {
+		"template": "Layout",
+		"placeLarge": "Posição {{n}} · grande",
+		"placeSmall": "Posição {{n}} · pequena",
+		"placeLeft": "Posição {{n}} · esquerda",
+		"placeRight": "Posição {{n}} · direita",
+		"cameraUnavailable": "{{name}} (indisponível)",
+		"resetWindows": "Redefinir janelas"
+	},
+	"cameras": {
+		"cameraN": "Câmera {{n}}",
+		"cameraNamed": "Câmera {{n}} · {{label}}",
+		"title": "Câmeras",
+		"unavailable": "Indisponível",
+		"camera1Hint": "Rotação, espelhamento e recorte da câmera 1 ficam nos controles acima.",
+		"rotation": "Rotação",
+		"mirror": "Espelhar",
+		"crop": "Recorte…",
+		"perspective": "Corrigir perspectiva…",
+		"reset": "Redefinir",
+		"cropOffWithPerspective": "O recorte não tem efeito enquanto houver uma perspectiva definida."
 	}
 }
diff --git a/src/i18n/locales/pt-BR/timeline.json b/src/i18n/locales/pt-BR/timeline.json
index 5bfc4aca2..768c79623 100644
--- a/src/i18n/locales/pt-BR/timeline.json
+++ b/src/i18n/locales/pt-BR/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "Adicionar um recorte: remove uma parte do vídeo no momento atual",
 		"addAnnotation": "Adicionar texto, seta, imagem ou desfoque no momento atual",
 		"addSpeed": "Adicionar uma mudança de velocidade no momento atual",
-		"addCameraFullscreen": "Adicionar Câmera em Tela Cheia: mostra a câmera em tela cheia no momento atual"
+		"addCameraFullscreen": "Adicionar Câmera em Tela Cheia: mostra a câmera em tela cheia no momento atual",
+		"addLayout": "Adicionar layout: disposição de tela e câmeras para uma seção"
 	},
 	"hints": {
 		"pressZoom": "Pressione {{key}} para adicionar zoom",
@@ -31,7 +32,11 @@
 		"imageItem": "Imagem",
 		"emptyText": "Texto vazio",
 		"cameraFullscreen": "Câmera em Tela Cheia",
-		"cameraFullscreenItem": "Câmera em Tela Cheia {{index}}"
+		"cameraFullscreenItem": "Câmera em Tela Cheia {{index}}",
+		"layoutScreenPip": "Tela + câmera",
+		"layoutCameraFull": "Câmera em tela cheia",
+		"layoutCameraFullPip": "Câmera + inserção",
+		"layoutSideBySide": "Lado a lado"
 	},
 	"emptyState": {
 		"noVideo": "Nenhum Vídeo Carregado",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "Não é possível colocar velocidade aqui",
 		"speedExistsAtLocation": "Já existe uma região de velocidade neste local ou não há espaço suficiente disponível.",
 		"cannotPlaceCameraFullscreen": "Não é possível colocar Câmera em Tela Cheia aqui",
-		"cameraFullscreenExistsAtLocation": "Já existe um segmento de Câmera em Tela Cheia neste local ou não há espaço suficiente disponível."
+		"cameraFullscreenExistsAtLocation": "Já existe um segmento de Câmera em Tela Cheia neste local ou não há espaço suficiente disponível.",
+		"tooFewCameras": "Este layout precisa de mais câmeras do que as disponíveis aqui",
+		"cannotPlaceCameraSection": "Não é possível colocar uma seção de câmera aqui",
+		"cameraSectionExistsAtLocation": "Já existe uma seção de câmera aqui.",
+		"noCamera": "Este projeto não tem câmera"
 	},
 	"success": {
 		"addedZoomSuggestions": "Adicionada {{count}} sugestão de zoom baseada no cursor",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "A gravação não está disponível aqui",
 		"saveFailed": "Não foi possível salvar a gravação",
 		"importFailed": "Não foi possível importar o arquivo de áudio"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "Indisponível com esta predefinição de layout",
+		"needsCamerasHint": "Precisa de mais câmeras"
 	}
 }
diff --git a/src/i18n/locales/ru/dialogs.json b/src/i18n/locales/ru/dialogs.json
index 1f46a14fc..15de80a43 100644
--- a/src/i18n/locales/ru/dialogs.json
+++ b/src/i18n/locales/ru/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "Аудиофайлы",
 		"openscreenProject": "Проект OpenScreen",
 		"allFiles": "Все файлы"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "Исправить перспективу – {{camera}}",
+		"titleCrop": "Обрезать – {{camera}}",
+		"loading": "Загрузка изображения камеры…",
+		"loadFailed": "Не удалось загрузить изображение камеры.",
+		"perspectiveHelp": "Перетащите четыре угла на углы листа или стола. Стрелки сдвигают выбранный угол на один пиксель, с Shift — на десять.",
+		"cropIgnored": "У этой камеры есть обрезка; пока задана перспектива, она не учитывается.",
+		"cropHelp": "Перетащите рамку или её маркеры на ту часть изображения, которую нужно оставить. Стрелки сдвигают её, Shift + стрелки меняют размер.",
+		"corners": {
+			"topLeft": "Левый верхний угол",
+			"topRight": "Правый верхний угол",
+			"bottomRight": "Правый нижний угол",
+			"bottomLeft": "Левый нижний угол"
+		},
+		"format": "Целевой формат",
+		"formats": {
+			"a4Portrait": "A4 книжный",
+			"a4Landscape": "A4 альбомный",
+			"free": "Свободный"
+		},
+		"freeRatio": "Соотношение (ширина ÷ высота)",
+		"margin": "Поля",
+		"preview": "Предпросмотр",
+		"loupe": "Лупа",
+		"cropArea": "Область обрезки",
+		"invalidQuad": "Углы пересекаются, лежат на одной линии или образуют вогнутую (невыпуклую) фигуру. Расположите их выпуклым четырёхугольником, чтобы применить.",
+		"reset": "Сбросить",
+		"apply": "Применить",
+		"invalidRatio": "Введите соотношение от {{min}} до {{max}}.",
+		"detectMarkers": "Распознать маркеры",
+		"printMarkerSheet": "Распечатать лист маркеров",
+		"markersFound": "Найдены все четыре маркера; углы установлены по ним.",
+		"markersNotFound": "Найдены не все четыре маркера (0–3). Убедитесь, что они целиком в кадре, лежат ровно и равномерно освещены. Углы остались без изменений.",
+		"markerSheetInstruction": "Вырежьте по пунктиру. Внутренний угол маркера — точно на его угол."
 	}
 }
diff --git a/src/i18n/locales/ru/editor.json b/src/i18n/locales/ru/editor.json
index 096daf5e7..d76187acf 100644
--- a/src/i18n/locales/ru/editor.json
+++ b/src/i18n/locales/ru/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "Предпросмотр видео",
 		"webcamPreview": "Предпросмотр камеры",
+		"layoutPlace": "Окно камеры — перетащите, чтобы переместить",
+		"layoutPlaceResize": "Изменить размер окна камеры",
 		"mediaError": {
 			"title": "Предпросмотр остановлен",
 			"description": "Не удалось декодировать видео. Файл может быть повреждён, ещё записываться или больше не находиться там, где его ожидает проект — сам проект не пострадал.",
diff --git a/src/i18n/locales/ru/settings.json b/src/i18n/locales/ru/settings.json
index 6935b8570..d0b0fb552 100644
--- a/src/i18n/locales/ru/settings.json
+++ b/src/i18n/locales/ru/settings.json
@@ -462,5 +462,27 @@
 		"dark": "Тёмная",
 		"light": "Светлая",
 		"custom": "Своя"
+	},
+	"cameraLayout": {
+		"template": "Макет",
+		"placeLarge": "Место {{n}} · большое",
+		"placeSmall": "Место {{n}} · малое",
+		"placeLeft": "Место {{n}} · слева",
+		"placeRight": "Место {{n}} · справа",
+		"cameraUnavailable": "{{name}} (недоступна)",
+		"resetWindows": "Сбросить окна"
+	},
+	"cameras": {
+		"cameraN": "Камера {{n}}",
+		"cameraNamed": "Камера {{n}} · {{label}}",
+		"title": "Камеры",
+		"unavailable": "Недоступна",
+		"camera1Hint": "Поворот, отражение и обрезка камеры 1 находятся в элементах управления выше.",
+		"rotation": "Поворот",
+		"mirror": "Отразить",
+		"crop": "Обрезка…",
+		"perspective": "Исправить перспективу…",
+		"reset": "Сбросить",
+		"cropOffWithPerspective": "Пока задана перспектива, обрезка не действует."
 	}
 }
diff --git a/src/i18n/locales/ru/timeline.json b/src/i18n/locales/ru/timeline.json
index fb019b9ad..4a7db745a 100644
--- a/src/i18n/locales/ru/timeline.json
+++ b/src/i18n/locales/ru/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "Добавить обрезку: удаляет фрагмент видео в текущий момент",
 		"addAnnotation": "Добавить текст, стрелку, изображение или размытие в текущий момент",
 		"addSpeed": "Добавить изменение скорости в текущий момент",
-		"addCameraFullscreen": "Добавить камеру на весь экран: показывает камеру на весь экран в текущий момент"
+		"addCameraFullscreen": "Добавить камеру на весь экран: показывает камеру на весь экран в текущий момент",
+		"addLayout": "Добавить раскладку: расположение экрана и камер для фрагмента"
 	},
 	"hints": {
 		"pressZoom": "Нажмите {{key}} для добавления масштабирования",
@@ -31,7 +32,11 @@
 		"imageItem": "Изображение",
 		"emptyText": "Пустой текст",
 		"cameraFullscreen": "Камера на весь экран",
-		"cameraFullscreenItem": "Камера на весь экран {{index}}"
+		"cameraFullscreenItem": "Камера на весь экран {{index}}",
+		"layoutScreenPip": "Экран + камера",
+		"layoutCameraFull": "Камера на весь экран",
+		"layoutCameraFullPip": "Камера + вставка",
+		"layoutSideBySide": "Рядом"
 	},
 	"emptyState": {
 		"noVideo": "Видео не загружено",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "Невозможно разместить изменение скорости здесь",
 		"speedExistsAtLocation": "Область изменения скорости уже существует в этом месте или недостаточно свободного места.",
 		"cannotPlaceCameraFullscreen": "Невозможно разместить камеру на весь экран здесь",
-		"cameraFullscreenExistsAtLocation": "Сегмент камеры на весь экран уже существует в этом месте или недостаточно свободного места."
+		"cameraFullscreenExistsAtLocation": "Сегмент камеры на весь экран уже существует в этом месте или недостаточно свободного места.",
+		"tooFewCameras": "Для этой раскладки нужно больше камер, чем доступно здесь",
+		"cannotPlaceCameraSection": "Здесь нельзя разместить участок камеры",
+		"cameraSectionExistsAtLocation": "Здесь уже есть участок камеры.",
+		"noCamera": "В этом проекте нет камеры"
 	},
 	"success": {
 		"addedZoomSuggestions": "Добавлено {{count}} предложение масштабирования на основе курсора",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "Запись здесь недоступна",
 		"saveFailed": "Не удалось сохранить запись",
 		"importFailed": "Не удалось импортировать аудиофайл"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "Недоступно с этим пресетом раскладки",
+		"needsCamerasHint": "Нужно больше камер"
 	}
 }
diff --git a/src/i18n/locales/tr/dialogs.json b/src/i18n/locales/tr/dialogs.json
index 6b01da744..28e7c2e35 100644
--- a/src/i18n/locales/tr/dialogs.json
+++ b/src/i18n/locales/tr/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "Ses dosyaları",
 		"openscreenProject": "OpenScreen Projesi",
 		"allFiles": "Tüm Dosyalar"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "Perspektifi düzelt – {{camera}}",
+		"titleCrop": "Kırp – {{camera}}",
+		"loading": "Kamera görüntüsü yükleniyor…",
+		"loadFailed": "Kamera görüntüsü yüklenemedi.",
+		"perspectiveHelp": "Dört köşeyi kâğıdın veya masanın köşelerine sürükleyin. Ok tuşları seçili köşeyi bir piksel, Shift ile on piksel taşır.",
+		"cropIgnored": "Bu kamerada kırpma var; perspektif ayarlıyken kırpma yok sayılır.",
+		"cropHelp": "Çerçeveyi veya tutamaçlarını görüntünün kalacak kısmına sürükleyin. Ok tuşları onu taşır, Shift + ok tuşları boyutunu değiştirir.",
+		"corners": {
+			"topLeft": "Sol üst köşe",
+			"topRight": "Sağ üst köşe",
+			"bottomRight": "Sağ alt köşe",
+			"bottomLeft": "Sol alt köşe"
+		},
+		"format": "Hedef biçim",
+		"formats": {
+			"a4Portrait": "A4 dikey",
+			"a4Landscape": "A4 yatay",
+			"free": "Serbest"
+		},
+		"freeRatio": "Oran (genişlik ÷ yükseklik)",
+		"margin": "Kenar boşluğu",
+		"preview": "Önizleme",
+		"loupe": "Büyüteç",
+		"cropArea": "Kırpma alanı",
+		"invalidQuad": "Köşeler kesişiyor, aynı doğru üzerinde veya içe göçük (dışbükey olmayan) bir şekil oluşturuyor. Uygulamak için onları dışbükey bir dörtgen oluşturacak şekilde yerleştirin.",
+		"reset": "Sıfırla",
+		"apply": "Uygula",
+		"invalidRatio": "{{min}} ile {{max}} arasında bir oran girin.",
+		"detectMarkers": "İşaretçileri algıla",
+		"printMarkerSheet": "İşaretçi sayfasını yazdır",
+		"markersFound": "Dört işaretçinin tümü bulundu; köşeler bunların üzerine yerleştirildi.",
+		"markersNotFound": "Dört işaretçinin (0–3) tümü bulunamadı. Tamamen görüntüde, düz ve eşit aydınlatılmış olduklarından emin olun. Köşeler değiştirilmedi.",
+		"markerSheetInstruction": "Kesikli çizgilerden kesin. Her işaretçinin iç köşesini kendi köşesine koyun."
 	}
 }
diff --git a/src/i18n/locales/tr/editor.json b/src/i18n/locales/tr/editor.json
index f4a76714e..a188b719d 100644
--- a/src/i18n/locales/tr/editor.json
+++ b/src/i18n/locales/tr/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "Video önizlemesi",
 		"webcamPreview": "Kamera önizlemesi",
+		"layoutPlace": "Kamera penceresi — taşımak için sürükleyin",
+		"layoutPlaceResize": "Kamera penceresini yeniden boyutlandır",
 		"mediaError": {
 			"title": "Önizleme durdu",
 			"description": "Video çözümlenemedi. Dosya bozulmuş, hâlâ yazılıyor ya da projenin beklediği yerde olmayabilir — projeniz olduğu gibi duruyor.",
diff --git a/src/i18n/locales/tr/settings.json b/src/i18n/locales/tr/settings.json
index 8d6810bb2..cb916c9fa 100644
--- a/src/i18n/locales/tr/settings.json
+++ b/src/i18n/locales/tr/settings.json
@@ -462,5 +462,27 @@
 		"dark": "Koyu",
 		"light": "Açık",
 		"custom": "Özel"
+	},
+	"cameraLayout": {
+		"template": "Düzen",
+		"placeLarge": "Yer {{n}} · büyük",
+		"placeSmall": "Yer {{n}} · küçük",
+		"placeLeft": "Yer {{n}} · sol",
+		"placeRight": "Yer {{n}} · sağ",
+		"cameraUnavailable": "{{name}} (kullanılamıyor)",
+		"resetWindows": "Pencereleri sıfırla"
+	},
+	"cameras": {
+		"cameraN": "Kamera {{n}}",
+		"cameraNamed": "Kamera {{n}} · {{label}}",
+		"title": "Kameralar",
+		"unavailable": "Kullanılamıyor",
+		"camera1Hint": "Kamera 1'in döndürme, yansıtma ve kırpma ayarları yukarıdaki denetimlerdedir.",
+		"rotation": "Döndürme",
+		"mirror": "Yansıt",
+		"crop": "Kırp…",
+		"perspective": "Perspektifi düzelt…",
+		"reset": "Sıfırla",
+		"cropOffWithPerspective": "Perspektif ayarlıyken kırpmanın etkisi yoktur."
 	}
 }
diff --git a/src/i18n/locales/tr/timeline.json b/src/i18n/locales/tr/timeline.json
index c24dd7d61..c1700c2e1 100644
--- a/src/i18n/locales/tr/timeline.json
+++ b/src/i18n/locales/tr/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "Kırpma ekle: videonun bir bölümünü şu anki zamanda çıkarır",
 		"addAnnotation": "Şu anki zamanda metin, ok, resim veya bulanıklık ekle",
 		"addSpeed": "Şu anki zamanda hız değişikliği ekle",
-		"addCameraFullscreen": "Tam Ekran Kamera ekle: kamerayı şu anki zamanda tam ekran gösterir"
+		"addCameraFullscreen": "Tam Ekran Kamera ekle: kamerayı şu anki zamanda tam ekran gösterir",
+		"addLayout": "Düzen ekle: bir bölüm için ekran ve kamera yerleşimi"
 	},
 	"hints": {
 		"pressZoom": "Yakınlaştırma eklemek için {{key}} tuşuna basın",
@@ -31,7 +32,11 @@
 		"imageItem": "Görüntü",
 		"emptyText": "Boş metin",
 		"cameraFullscreen": "Tam Ekran Kamera",
-		"cameraFullscreenItem": "Tam Ekran Kamera {{index}}"
+		"cameraFullscreenItem": "Tam Ekran Kamera {{index}}",
+		"layoutScreenPip": "Ekran + kamera",
+		"layoutCameraFull": "Tam ekran kamera",
+		"layoutCameraFullPip": "Kamera + küçük pencere",
+		"layoutSideBySide": "Yan yana"
 	},
 	"emptyState": {
 		"noVideo": "Video Yüklenmedi",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "Buraya hız yerleştirilemiyor",
 		"speedExistsAtLocation": "Bu konumda zaten bir hız bölgesi var veya yeterli alan yok.",
 		"cannotPlaceCameraFullscreen": "Buraya Tam Ekran Kamera yerleştirilemiyor",
-		"cameraFullscreenExistsAtLocation": "Bu konumda zaten bir Tam Ekran Kamera bölümü var veya yeterli alan yok."
+		"cameraFullscreenExistsAtLocation": "Bu konumda zaten bir Tam Ekran Kamera bölümü var veya yeterli alan yok.",
+		"tooFewCameras": "Bu düzen, burada bulunandan daha fazla kamera gerektirir",
+		"cannotPlaceCameraSection": "Buraya kamera bölümü yerleştirilemez",
+		"cameraSectionExistsAtLocation": "Burada zaten bir kamera bölümü var.",
+		"noCamera": "Bu projede kamera yok"
 	},
 	"success": {
 		"addedZoomSuggestions": "{{count}} imleç tabanlı yakınlaştırma önerisi eklendi",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "Burada kayıt kullanılamıyor",
 		"saveFailed": "Kayıt kaydedilemedi",
 		"importFailed": "Ses dosyası içe aktarılamadı"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "Bu düzen ön ayarıyla kullanılamaz",
+		"needsCamerasHint": "Daha fazla kamera gerekir"
 	}
 }
diff --git a/src/i18n/locales/vi/dialogs.json b/src/i18n/locales/vi/dialogs.json
index 452e80e2f..4db70f4f1 100644
--- a/src/i18n/locales/vi/dialogs.json
+++ b/src/i18n/locales/vi/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "Tệp âm thanh",
 		"openscreenProject": "Dự án OpenScreen",
 		"allFiles": "Tất cả các tệp"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "Chỉnh phối cảnh – {{camera}}",
+		"titleCrop": "Cắt – {{camera}}",
+		"loading": "Đang tải hình ảnh camera…",
+		"loadFailed": "Không thể tải hình ảnh camera.",
+		"perspectiveHelp": "Kéo bốn góc vào các góc của tờ giấy hoặc mặt bàn. Phím mũi tên di chuyển góc đang chọn một pixel, giữ Shift để di chuyển mười pixel.",
+		"cropIgnored": "Camera này có vùng cắt; vùng cắt bị bỏ qua khi đã đặt phối cảnh.",
+		"cropHelp": "Kéo khung hoặc các tay cầm của nó lên phần hình ảnh cần giữ. Phím mũi tên di chuyển khung, Shift + mũi tên thay đổi kích thước.",
+		"corners": {
+			"topLeft": "Góc trên bên trái",
+			"topRight": "Góc trên bên phải",
+			"bottomRight": "Góc dưới bên phải",
+			"bottomLeft": "Góc dưới bên trái"
+		},
+		"format": "Định dạng đích",
+		"formats": {
+			"a4Portrait": "A4 dọc",
+			"a4Landscape": "A4 ngang",
+			"free": "Tự do"
+		},
+		"freeRatio": "Tỉ lệ (rộng ÷ cao)",
+		"margin": "Lề",
+		"preview": "Xem trước",
+		"loupe": "Kính lúp",
+		"cropArea": "Vùng cắt",
+		"invalidQuad": "Các góc cắt nhau, nằm trên một đường thẳng hoặc tạo thành hình lõm (không lồi). Hãy sắp xếp chúng thành hình tứ giác lồi để áp dụng.",
+		"reset": "Đặt lại",
+		"apply": "Áp dụng",
+		"invalidRatio": "Nhập tỷ lệ từ {{min}} đến {{max}}.",
+		"detectMarkers": "Phát hiện điểm đánh dấu",
+		"printMarkerSheet": "In trang điểm đánh dấu",
+		"markersFound": "Đã tìm thấy cả bốn điểm đánh dấu; các góc đã được đặt lên chúng.",
+		"markersNotFound": "Không tìm thấy đủ bốn điểm đánh dấu (0–3). Hãy đảm bảo chúng nằm trọn trong khung hình, phẳng và được chiếu sáng đều. Các góc được giữ nguyên.",
+		"markerSheetInstruction": "Cắt theo nét đứt. Đặt góc trong của mỗi điểm đánh dấu vào góc tương ứng."
 	}
 }
diff --git a/src/i18n/locales/vi/editor.json b/src/i18n/locales/vi/editor.json
index 1ab9da48c..40cfddce9 100644
--- a/src/i18n/locales/vi/editor.json
+++ b/src/i18n/locales/vi/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "Xem trước video",
 		"webcamPreview": "Xem trước máy ảnh",
+		"layoutPlace": "Cửa sổ camera — kéo để di chuyển",
+		"layoutPlaceResize": "Đổi kích thước cửa sổ camera",
 		"mediaError": {
 			"title": "Xem trước đã dừng",
 			"description": "Không thể giải mã video. Tệp có thể đã hỏng, vẫn đang được ghi, hoặc không còn ở nơi dự án mong đợi — dự án của bạn vẫn nguyên vẹn.",
diff --git a/src/i18n/locales/vi/settings.json b/src/i18n/locales/vi/settings.json
index 426a820da..855c30777 100644
--- a/src/i18n/locales/vi/settings.json
+++ b/src/i18n/locales/vi/settings.json
@@ -462,5 +462,27 @@
 		"dark": "Tối",
 		"light": "Sáng",
 		"custom": "Tùy chỉnh"
+	},
+	"cameraLayout": {
+		"template": "Bố cục",
+		"placeLarge": "Vị trí {{n}} · lớn",
+		"placeSmall": "Vị trí {{n}} · nhỏ",
+		"placeLeft": "Vị trí {{n}} · trái",
+		"placeRight": "Vị trí {{n}} · phải",
+		"cameraUnavailable": "{{name}} (không khả dụng)",
+		"resetWindows": "Đặt lại cửa sổ"
+	},
+	"cameras": {
+		"cameraN": "Camera {{n}}",
+		"cameraNamed": "Camera {{n}} · {{label}}",
+		"title": "Camera",
+		"unavailable": "Không khả dụng",
+		"camera1Hint": "Xoay, lật gương và cắt của camera 1 nằm ở các điều khiển phía trên.",
+		"rotation": "Xoay",
+		"mirror": "Lật gương",
+		"crop": "Cắt…",
+		"perspective": "Chỉnh phối cảnh…",
+		"reset": "Đặt lại",
+		"cropOffWithPerspective": "Cắt khung không có tác dụng khi đã đặt phối cảnh."
 	}
 }
diff --git a/src/i18n/locales/vi/timeline.json b/src/i18n/locales/vi/timeline.json
index 3bdc702c6..c843fccba 100644
--- a/src/i18n/locales/vi/timeline.json
+++ b/src/i18n/locales/vi/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "Thêm cắt: xóa một đoạn video tại thời điểm hiện tại",
 		"addAnnotation": "Thêm văn bản, mũi tên, hình ảnh hoặc làm mờ tại thời điểm hiện tại",
 		"addSpeed": "Thêm thay đổi tốc độ tại thời điểm hiện tại",
-		"addCameraFullscreen": "Thêm Camera Toàn màn hình: hiển thị camera toàn màn hình tại thời điểm hiện tại"
+		"addCameraFullscreen": "Thêm Camera Toàn màn hình: hiển thị camera toàn màn hình tại thời điểm hiện tại",
+		"addLayout": "Thêm bố cục: cách sắp xếp màn hình và camera cho một đoạn"
 	},
 	"hints": {
 		"pressZoom": "Nhấn {{key}} để thêm thu phóng",
@@ -31,7 +32,11 @@
 		"imageItem": "Hình ảnh",
 		"emptyText": "Văn bản trống",
 		"cameraFullscreen": "Camera Toàn màn hình",
-		"cameraFullscreenItem": "Camera Toàn màn hình {{index}}"
+		"cameraFullscreenItem": "Camera Toàn màn hình {{index}}",
+		"layoutScreenPip": "Màn hình + camera",
+		"layoutCameraFull": "Camera toàn màn hình",
+		"layoutCameraFullPip": "Camera + khung nhỏ",
+		"layoutSideBySide": "Cạnh nhau"
 	},
 	"emptyState": {
 		"noVideo": "Chưa tải video",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "Không thể đặt tốc độ ở đây",
 		"speedExistsAtLocation": "Vùng tốc độ đã tồn tại ở vị trí này hoặc không có đủ không gian.",
 		"cannotPlaceCameraFullscreen": "Không thể đặt Camera Toàn màn hình ở đây",
-		"cameraFullscreenExistsAtLocation": "Đoạn Camera Toàn màn hình đã tồn tại ở vị trí này hoặc không có đủ không gian."
+		"cameraFullscreenExistsAtLocation": "Đoạn Camera Toàn màn hình đã tồn tại ở vị trí này hoặc không có đủ không gian.",
+		"tooFewCameras": "Bố cục này cần nhiều camera hơn số hiện có",
+		"cannotPlaceCameraSection": "Không thể đặt đoạn camera tại đây",
+		"cameraSectionExistsAtLocation": "Đã có một đoạn camera tại đây.",
+		"noCamera": "Dự án này không có camera"
 	},
 	"success": {
 		"addedZoomSuggestions": "Đã thêm {{count}} đề xuất thu phóng dựa trên con trỏ",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "Không thể ghi âm ở đây",
 		"saveFailed": "Không thể lưu bản ghi",
 		"importFailed": "Không thể nhập tệp âm thanh"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "Không khả dụng với bố cục cài sẵn này",
+		"needsCamerasHint": "Cần thêm camera"
 	}
 }
diff --git a/src/i18n/locales/zh-CN/dialogs.json b/src/i18n/locales/zh-CN/dialogs.json
index db4f12730..975908055 100644
--- a/src/i18n/locales/zh-CN/dialogs.json
+++ b/src/i18n/locales/zh-CN/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "音频文件",
 		"openscreenProject": "OpenScreen 项目",
 		"allFiles": "所有文件"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "校正透视 – {{camera}}",
+		"titleCrop": "裁剪 – {{camera}}",
+		"loading": "正在加载摄像头画面…",
+		"loadFailed": "无法加载摄像头画面。",
+		"perspectiveHelp": "将四个角拖到纸张或桌面的角上。方向键可将所选角移动 1 像素，按住 Shift 移动 10 像素。",
+		"cropIgnored": "此摄像头设置了裁剪；设置透视校正时将忽略裁剪。",
+		"cropHelp": "将边框或其控制点拖到要保留的画面部分。方向键移动边框，Shift + 方向键调整大小。",
+		"corners": {
+			"topLeft": "左上角",
+			"topRight": "右上角",
+			"bottomRight": "右下角",
+			"bottomLeft": "左下角"
+		},
+		"format": "目标格式",
+		"formats": {
+			"a4Portrait": "A4 纵向",
+			"a4Landscape": "A4 横向",
+			"free": "自由"
+		},
+		"freeRatio": "比例（宽 ÷ 高）",
+		"margin": "边距",
+		"preview": "预览",
+		"loupe": "放大镜",
+		"cropArea": "裁剪区域",
+		"invalidQuad": "这些角相互交叉、位于同一直线上，或构成内凹（非凸）的形状。请将它们摆成凸四边形后再应用。",
+		"reset": "重置",
+		"apply": "应用",
+		"invalidRatio": "请输入 {{min}} 到 {{max}} 之间的比例。",
+		"detectMarkers": "检测标记",
+		"printMarkerSheet": "打印标记纸",
+		"markersFound": "已找到全部四个标记，角点已放到标记上。",
+		"markersNotFound": "未找到全部四个标记（0–3）。请确保它们完整地位于画面中、平整且光照均匀。角点保持不变。",
+		"markerSheetInstruction": "沿虚线剪下，将每个标记的内侧角对准其标注的角。"
 	}
 }
diff --git a/src/i18n/locales/zh-CN/editor.json b/src/i18n/locales/zh-CN/editor.json
index 98a12b084..d813b6cc6 100644
--- a/src/i18n/locales/zh-CN/editor.json
+++ b/src/i18n/locales/zh-CN/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "视频预览",
 		"webcamPreview": "摄像头预览",
+		"layoutPlace": "摄像头窗口 — 拖动以移动",
+		"layoutPlaceResize": "调整摄像头窗口大小",
 		"mediaError": {
 			"title": "预览已停止",
 			"description": "无法解码该视频。文件可能已损坏、仍在写入中，或已不在项目预期的位置——你的项目本身完好无损。",
diff --git a/src/i18n/locales/zh-CN/settings.json b/src/i18n/locales/zh-CN/settings.json
index 77472879b..559cb71c8 100644
--- a/src/i18n/locales/zh-CN/settings.json
+++ b/src/i18n/locales/zh-CN/settings.json
@@ -462,5 +462,27 @@
 		"dark": "深色",
 		"light": "浅色",
 		"custom": "自定义"
+	},
+	"cameraLayout": {
+		"template": "布局",
+		"placeLarge": "位置 {{n}} · 大",
+		"placeSmall": "位置 {{n}} · 小",
+		"placeLeft": "位置 {{n}} · 左",
+		"placeRight": "位置 {{n}} · 右",
+		"cameraUnavailable": "{{name}}（不可用）",
+		"resetWindows": "重置窗口"
+	},
+	"cameras": {
+		"cameraN": "摄像头 {{n}}",
+		"cameraNamed": "摄像头 {{n}} · {{label}}",
+		"title": "摄像头",
+		"unavailable": "不可用",
+		"camera1Hint": "摄像头 1 的旋转、镜像和裁剪在上方的控件中设置。",
+		"rotation": "旋转",
+		"mirror": "镜像",
+		"crop": "裁剪…",
+		"perspective": "校正透视…",
+		"reset": "重置",
+		"cropOffWithPerspective": "设置了透视校正时，裁剪不起作用。"
 	}
 }
diff --git a/src/i18n/locales/zh-CN/timeline.json b/src/i18n/locales/zh-CN/timeline.json
index 4d14f67ee..f13fda557 100644
--- a/src/i18n/locales/zh-CN/timeline.json
+++ b/src/i18n/locales/zh-CN/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "添加剪辑：在当前时间移除一段视频",
 		"addAnnotation": "在当前时间添加文字、箭头、图片或模糊",
 		"addSpeed": "在当前时间添加速度变化",
-		"addCameraFullscreen": "添加全屏摄像头：在当前时间全屏显示摄像头"
+		"addCameraFullscreen": "添加全屏摄像头：在当前时间全屏显示摄像头",
+		"addLayout": "添加布局：为片段设置屏幕与摄像头的排布"
 	},
 	"hints": {
 		"pressZoom": "按 {{key}} 添加缩放",
@@ -31,7 +32,11 @@
 		"imageItem": "图片",
 		"emptyText": "空文本",
 		"cameraFullscreen": "全屏摄像头",
-		"cameraFullscreenItem": "全屏摄像头 {{index}}"
+		"cameraFullscreenItem": "全屏摄像头 {{index}}",
+		"layoutScreenPip": "屏幕 + 摄像头",
+		"layoutCameraFull": "摄像头全屏",
+		"layoutCameraFullPip": "摄像头 + 画中画",
+		"layoutSideBySide": "并排"
 	},
 	"emptyState": {
 		"noVideo": "未加载视频",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "无法在此处放置速度",
 		"speedExistsAtLocation": "此位置已存在速度区域或没有足够的空间。",
 		"cannotPlaceCameraFullscreen": "无法在此处放置全屏摄像头",
-		"cameraFullscreenExistsAtLocation": "此位置已存在全屏摄像头片段或没有足够的空间。"
+		"cameraFullscreenExistsAtLocation": "此位置已存在全屏摄像头片段或没有足够的空间。",
+		"tooFewCameras": "此布局所需的摄像头多于当前可用的数量",
+		"cannotPlaceCameraSection": "无法在此处放置摄像头片段",
+		"cameraSectionExistsAtLocation": "此处已有摄像头片段。",
+		"noCamera": "此项目没有摄像头"
 	},
 	"success": {
 		"addedZoomSuggestions": "已添加 {{count}} 个基于光标的缩放建议",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "此处无法录音",
 		"saveFailed": "无法保存录音",
 		"importFailed": "无法导入音频文件"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "此布局预设下不可用",
+		"needsCamerasHint": "需要更多摄像头"
 	}
 }
diff --git a/src/i18n/locales/zh-TW/dialogs.json b/src/i18n/locales/zh-TW/dialogs.json
index f4830a611..5a3f0db99 100644
--- a/src/i18n/locales/zh-TW/dialogs.json
+++ b/src/i18n/locales/zh-TW/dialogs.json
@@ -88,5 +88,40 @@
 		"audioFiles": "音訊檔案",
 		"openscreenProject": "OpenScreen 專案",
 		"allFiles": "所有檔案"
+	},
+	"cameraCalibration": {
+		"titlePerspective": "校正透視 – {{camera}}",
+		"titleCrop": "裁切 – {{camera}}",
+		"loading": "正在載入攝影機畫面…",
+		"loadFailed": "無法載入攝影機畫面。",
+		"perspectiveHelp": "將四個角拖到紙張或桌面的角上。方向鍵可將所選的角移動 1 像素，按住 Shift 則移動 10 像素。",
+		"cropIgnored": "此攝影機設定了裁切；設定透視校正時會忽略裁切。",
+		"cropHelp": "將框線或其控點拖到要保留的畫面部分。方向鍵移動框線，Shift + 方向鍵調整大小。",
+		"corners": {
+			"topLeft": "左上角",
+			"topRight": "右上角",
+			"bottomRight": "右下角",
+			"bottomLeft": "左下角"
+		},
+		"format": "目標格式",
+		"formats": {
+			"a4Portrait": "A4 直向",
+			"a4Landscape": "A4 橫向",
+			"free": "自由"
+		},
+		"freeRatio": "比例（寬 ÷ 高）",
+		"margin": "邊距",
+		"preview": "預覽",
+		"loupe": "放大鏡",
+		"cropArea": "裁切區域",
+		"invalidQuad": "這些角互相交叉、位於同一直線上，或構成內凹（非凸）的形狀。請將它們排成凸四邊形後再套用。",
+		"reset": "重設",
+		"apply": "套用",
+		"invalidRatio": "請輸入 {{min}} 到 {{max}} 之間的比例。",
+		"detectMarkers": "偵測標記",
+		"printMarkerSheet": "列印標記紙",
+		"markersFound": "已找到全部四個標記，角點已放到標記上。",
+		"markersNotFound": "未找到全部四個標記（0–3）。請確認它們完整位於畫面中、平整且光線均勻。角點維持不變。",
+		"markerSheetInstruction": "沿虛線剪下，將每個標記的內側角對準其標示的角。"
 	}
 }
diff --git a/src/i18n/locales/zh-TW/editor.json b/src/i18n/locales/zh-TW/editor.json
index 8862c279a..0e76e50ab 100644
--- a/src/i18n/locales/zh-TW/editor.json
+++ b/src/i18n/locales/zh-TW/editor.json
@@ -361,6 +361,8 @@
 	"preview": {
 		"videoPreview": "影片預覽",
 		"webcamPreview": "攝影機預覽",
+		"layoutPlace": "攝影機視窗 — 拖曳以移動",
+		"layoutPlaceResize": "調整攝影機視窗大小",
 		"mediaError": {
 			"title": "預覽已停止",
 			"description": "無法解碼此影片。檔案可能已損毀、仍在寫入中，或已不在專案預期的位置——你的專案本身完好無缺。",
diff --git a/src/i18n/locales/zh-TW/settings.json b/src/i18n/locales/zh-TW/settings.json
index e47ff0583..08ffb9bde 100644
--- a/src/i18n/locales/zh-TW/settings.json
+++ b/src/i18n/locales/zh-TW/settings.json
@@ -462,5 +462,27 @@
 		"dark": "深色",
 		"light": "淺色",
 		"custom": "自訂"
+	},
+	"cameraLayout": {
+		"template": "版面配置",
+		"placeLarge": "位置 {{n}} · 大",
+		"placeSmall": "位置 {{n}} · 小",
+		"placeLeft": "位置 {{n}} · 左",
+		"placeRight": "位置 {{n}} · 右",
+		"cameraUnavailable": "{{name}}（無法使用）",
+		"resetWindows": "重設視窗"
+	},
+	"cameras": {
+		"cameraN": "攝影機 {{n}}",
+		"cameraNamed": "攝影機 {{n}} · {{label}}",
+		"title": "攝影機",
+		"unavailable": "無法使用",
+		"camera1Hint": "攝影機 1 的旋轉、鏡像與裁切在上方的控制項中設定。",
+		"rotation": "旋轉",
+		"mirror": "鏡像",
+		"crop": "裁切…",
+		"perspective": "校正透視…",
+		"reset": "重設",
+		"cropOffWithPerspective": "設定了透視校正時，裁切不會生效。"
 	}
 }
diff --git a/src/i18n/locales/zh-TW/timeline.json b/src/i18n/locales/zh-TW/timeline.json
index 948a87cc5..78139d035 100644
--- a/src/i18n/locales/zh-TW/timeline.json
+++ b/src/i18n/locales/zh-TW/timeline.json
@@ -7,7 +7,8 @@
 		"addTrim": "新增剪輯：在目前時間移除一段影片",
 		"addAnnotation": "在目前時間新增文字、箭頭、圖片或模糊",
 		"addSpeed": "在目前時間新增速度變化",
-		"addCameraFullscreen": "新增全螢幕攝影機：在目前時間全螢幕顯示攝影機"
+		"addCameraFullscreen": "新增全螢幕攝影機：在目前時間全螢幕顯示攝影機",
+		"addLayout": "新增版面：為片段設定畫面與攝影機的排列"
 	},
 	"hints": {
 		"pressZoom": "按 {{key}} 新增縮放",
@@ -31,7 +32,11 @@
 		"imageItem": "圖片",
 		"emptyText": "空文字",
 		"cameraFullscreen": "全螢幕攝影機",
-		"cameraFullscreenItem": "全螢幕攝影機 {{index}}"
+		"cameraFullscreenItem": "全螢幕攝影機 {{index}}",
+		"layoutScreenPip": "畫面 + 攝影機",
+		"layoutCameraFull": "攝影機全螢幕",
+		"layoutCameraFullPip": "攝影機 + 子母畫面",
+		"layoutSideBySide": "並排"
 	},
 	"emptyState": {
 		"noVideo": "未載入影片",
@@ -54,7 +59,11 @@
 		"cannotPlaceSpeed": "無法在此處放置速度",
 		"speedExistsAtLocation": "此位置已存在速度區域或沒有足夠的空間。",
 		"cannotPlaceCameraFullscreen": "無法在此處放置全螢幕攝影機",
-		"cameraFullscreenExistsAtLocation": "此位置已存在全螢幕攝影機片段或沒有足夠的空間。"
+		"cameraFullscreenExistsAtLocation": "此位置已存在全螢幕攝影機片段或沒有足夠的空間。",
+		"tooFewCameras": "此版面所需的攝影機多於目前可用的數量",
+		"cannotPlaceCameraSection": "無法在此處放置攝影機片段",
+		"cameraSectionExistsAtLocation": "此處已有攝影機片段。",
+		"noCamera": "此專案沒有攝影機"
 	},
 	"success": {
 		"addedZoomSuggestions": "已新增 {{count}} 個基於游標的縮放建議",
@@ -103,5 +112,9 @@
 		"recordingUnavailable": "此處無法錄音",
 		"saveFailed": "無法儲存錄音",
 		"importFailed": "無法匯入音訊檔案"
+	},
+	"layoutMenu": {
+		"blockLayoutHint": "此版面預設下無法使用",
+		"needsCamerasHint": "需要更多攝影機"
 	}
 }
diff --git a/src/lib/ai-edition/document/timeline.test.ts b/src/lib/ai-edition/document/timeline.test.ts
index 5bd56c22b..cba48805a 100644
--- a/src/lib/ai-edition/document/timeline.test.ts
+++ b/src/lib/ai-edition/document/timeline.test.ts
@@ -7,6 +7,8 @@ import {
 } from "../schema";
 import {
 	buildTimelineFromIntervals,
+	clearEditRegions,
+	countEditRegions,
 	duplicateClip,
 	invertIntervals,
 	moveClip,
@@ -1761,3 +1763,68 @@ describe("readSpeedRegions", () => {
 		expect(readSpeedRegions({ legacyEditor: null })).toEqual([]);
 	});
 });
+
+describe("camera layout regions", () => {
+	const layoutRow = {
+		id: "camlayout_1",
+		clipId: "clip_b",
+		assetId: "asset_1",
+		sourceStartSec: 22,
+		sourceEndSec: 24,
+		startMs: 12000,
+		endMs: 14000,
+		template: "screen-pip",
+		slots: [{ camera: 1 }],
+	};
+	const twoClips = () => ({
+		...makeDoc().timeline,
+		clips: [
+			makeClip({ id: "clip_a", sourceStartSec: 0, sourceEndSec: 10, timelineEndSec: 10 }),
+			makeClip({
+				id: "clip_b",
+				sourceStartSec: 20,
+				sourceEndSec: 30,
+				timelineStartSec: 10,
+				timelineEndSec: 20,
+			}),
+		],
+	});
+	type Layouts = { cameraLayoutRegions: Array<typeof layoutRow> };
+
+	it("mapAllRegionCollections re-anchors layout regions", () => {
+		const doc = makeDoc({
+			timeline: twoClips(),
+			legacyEditor: { cameraLayoutRegions: [layoutRow] },
+		});
+		// clip_b moves to the front (delta -10 s); the layout row follows its clip.
+		const next = moveClip(doc, "clip_b", 0);
+		expect((next.legacyEditor as Layouts).cameraLayoutRegions).toEqual([
+			{ ...layoutRow, startMs: 2000, endMs: 4000 },
+		]);
+	});
+
+	it("removeRegion removes a layout pill", () => {
+		const doc = makeDoc({
+			timeline: twoClips(),
+			legacyEditor: {
+				cameraFullscreenRegions: [{ id: "cf1", startMs: 0, endMs: 1000 }],
+				cameraLayoutRegions: [layoutRow],
+			},
+		});
+		const next = removeRegion(doc, "cameraLayout", "camlayout_1");
+		const legacy = next.legacyEditor as Layouts & { cameraFullscreenRegions: unknown[] };
+		expect(legacy.cameraLayoutRegions).toEqual([]);
+		expect(legacy.cameraFullscreenRegions).toHaveLength(1);
+	});
+
+	it("clearEditRegions clears layout regions", () => {
+		const doc = makeDoc({
+			timeline: twoClips(),
+			legacyEditor: { cameraLayoutRegions: [layoutRow] },
+		});
+		expect(countEditRegions(doc)).toBe(1);
+		const next = clearEditRegions(doc);
+		expect((next.legacyEditor as Layouts).cameraLayoutRegions).toEqual([]);
+		expect(countEditRegions(next)).toBe(0);
+	});
+});
diff --git a/src/lib/ai-edition/document/timeline.ts b/src/lib/ai-edition/document/timeline.ts
index 12fe026e1..21d2854b4 100644
--- a/src/lib/ai-edition/document/timeline.ts
+++ b/src/lib/ai-edition/document/timeline.ts
@@ -34,9 +34,16 @@ import { createId } from "./ids";
 
 /** The region families a delete can target by id. Shared with the store so "which kinds
  *  exist" has exactly one definition. `trim` is a source-time cut; the rest are pill-merged
- *  effects (zoom / speed / annotation / camera-fullscreen). Clips are removed via
- *  {@link removeClip}, not here — deleting a clip reflows the whole timeline. */
-export type RegionKind = "zoom" | "trim" | "annotation" | "speed" | "cameraFullscreen" | "audio";
+ *  effects (zoom / speed / annotation / camera-fullscreen / camera-layout). Clips are removed
+ *  via {@link removeClip}, not here — deleting a clip reflows the whole timeline. */
+export type RegionKind =
+	| "zoom"
+	| "trim"
+	| "annotation"
+	| "speed"
+	| "cameraFullscreen"
+	| "cameraLayout"
+	| "audio";
 
 /** Length a clip is given before its media has been probed. Lives here, in the pure
  *  document layer, because that layer decides which clips are still waiting for a real
@@ -351,7 +358,7 @@ type StoredRegion = {
 	sourceEndSec?: number;
 };
 
-/** Apply `fn` to all four modifier collections (document-level + legacyEditor envelopes). */
+/** Apply `fn` to every modifier collection (document-level + legacyEditor envelopes). */
 function mapAllRegionCollections(
 	document: AxcutDocument,
 	fn: (regions: StoredRegion[], prefix: string) => StoredRegion[],
@@ -370,6 +377,9 @@ function mapAllRegionCollections(
 	const cameraFullscreenRegions = Array.isArray(legacy?.cameraFullscreenRegions)
 		? (legacy?.cameraFullscreenRegions as StoredRegion[])
 		: undefined;
+	const cameraLayoutRegions = Array.isArray(legacy?.cameraLayoutRegions)
+		? (legacy?.cameraLayoutRegions as StoredRegion[])
+		: undefined;
 
 	return {
 		...document,
@@ -404,13 +414,16 @@ function mapAllRegionCollections(
 			),
 		),
 		legacyEditor:
-			legacy && (speedRegions || cameraFullscreenRegions)
+			legacy && (speedRegions || cameraFullscreenRegions || cameraLayoutRegions)
 				? {
 						...legacy,
 						...(speedRegions ? { speedRegions: fn(speedRegions, "speed") } : {}),
 						...(cameraFullscreenRegions
 							? { cameraFullscreenRegions: fn(cameraFullscreenRegions, "camfull") }
 							: {}),
+						...(cameraLayoutRegions
+							? { cameraLayoutRegions: fn(cameraLayoutRegions, "camlayout") }
+							: {}),
 					}
 				: document.legacyEditor,
 	};
@@ -719,7 +732,7 @@ function sameInterval(a: Interval, b: Interval): boolean {
 	);
 }
 
-/** Every anchored modifier of the document, all four families, as `{id, clipId}`. */
+/** Every anchored modifier of the document, every family, as `{id, clipId}`. */
 function anchoredRegionsOf(document: AxcutDocument): Array<{ id: string; clipId: string }> {
 	const legacy = document.legacyEditor as Record<string, unknown> | null;
 	const collections: StoredRegion[][] = [
@@ -727,6 +740,7 @@ function anchoredRegionsOf(document: AxcutDocument): Array<{ id: string; clipId:
 		document.annotations as unknown as StoredRegion[],
 		(legacy?.speedRegions as StoredRegion[] | undefined) ?? [],
 		(legacy?.cameraFullscreenRegions as StoredRegion[] | undefined) ?? [],
+		(legacy?.cameraLayoutRegions as StoredRegion[] | undefined) ?? [],
 	];
 	return collections
 		.flat()
@@ -1120,6 +1134,14 @@ export function removeRegion(document: AxcutDocument, kind: RegionKind, id: stri
 			);
 			return { ...document, legacyEditor: { ...legacy, cameraFullscreenRegions: prev } };
 		}
+		case "cameraLayout": {
+			const legacy = (document.legacyEditor as Record<string, unknown>) ?? {};
+			const prev = dropPillById(
+				(legacy.cameraLayoutRegions as Array<{ id: string; startMs: number; endMs: number }>) ?? [],
+				id,
+			);
+			return { ...document, legacyEditor: { ...legacy, cameraLayoutRegions: prev } };
+		}
 		default: {
 			// ponytail: exhaustive — TS errors here if a new RegionKind is added.
 			const exhaustive: never = kind;
@@ -1164,6 +1186,10 @@ const EDIT_REGIONS: Record<
 		count: (d) => legacyRegionCount(d, "cameraFullscreenRegions"),
 		clear: (d) => withLegacyRegionsCleared(d, "cameraFullscreenRegions"),
 	},
+	cameraLayout: {
+		count: (d) => legacyRegionCount(d, "cameraLayoutRegions"),
+		clear: (d) => withLegacyRegionsCleared(d, "cameraLayoutRegions"),
+	},
 };
 
 /** How many edit regions the document holds, stored rows and not pills. Pure. */
diff --git a/src/lib/ai-edition/store/documentWriteAudit.test.ts b/src/lib/ai-edition/store/documentWriteAudit.test.ts
index fcf02236e..48704120b 100644
--- a/src/lib/ai-edition/store/documentWriteAudit.test.ts
+++ b/src/lib/ai-edition/store/documentWriteAudit.test.ts
@@ -163,7 +163,6 @@ const DECLARED: WritePath[] = [
 	w("src/components/ai-edition/NewEditorShell.tsx", "pasteRegion", "save", "gesture"),
 	w("src/components/ai-edition/NewEditorShell.tsx", "pasteRegion", "save", "gesture"),
 	w("src/components/ai-edition/NewEditorShell.tsx", "pasteRegion", "save", "gesture"),
-	w("src/components/ai-edition/NewEditorShell.tsx", "pasteRegion", "save", "gesture"),
 	// The window is closing and the user answered "save".
 	w("src/components/ai-edition/NewEditorShell.tsx", "unsubSaveBeforeClose", "save", "gesture"),
 
@@ -250,6 +249,7 @@ const DECLARED: WritePath[] = [
 	w("src/lib/ai-edition/store/useTimeline.ts", "applyClipEdit", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "addAnnotation", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "addCameraFullscreen", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "addCameraLayout", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "addSpeed", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "addTrim", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "addZoom", "save", "gesture"),
@@ -263,6 +263,9 @@ const DECLARED: WritePath[] = [
 	// document back into the store, around the writers, so it records nothing. There is
 	// nothing to take off either — the commit records only on success.
 	w("src/lib/ai-edition/store/useTimeline.ts", "commitAnnotationChange", "state", "unrecorded"),
+	// The slot-rect drag of a layout section: the same commit and rollback pair.
+	w("src/lib/ai-edition/store/useTimeline.ts", "commitLayoutSlotRect", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "commitLayoutSlotRect", "state", "unrecorded"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "commitZoomFocus", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "commitZoomFocus", "state", "unrecorded"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "duplicateClip", "save", "gesture"),
@@ -287,7 +290,15 @@ const DECLARED: WritePath[] = [
 	w("src/lib/ai-edition/store/useTimeline.ts", "removeClip", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "removeRegion", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "removeRegions", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "resetLayoutSlotRects", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "saveZoomPatch", "save", "gesture"),
+	// Template and camera changes of a layout section, including a move between the
+	// Full Camera and layout lists: one save each, so one undo step.
+	// Two exits, one gesture each: a Full Camera region moving to the layout list, or a
+	// layout section changing a place (possibly moving to the Full Camera list).
+	w("src/lib/ai-edition/store/useTimeline.ts", "setLayoutSlotCamera", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "setLayoutSlotCamera", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "setLayoutTemplate", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "setTrimEntries", "save", "gesture"),
 	// The live halves of the two drags.
 	w("src/lib/ai-edition/store/useTimeline.ts", "updateAnnotationLive", "set", "automatic"),
@@ -298,6 +309,7 @@ const DECLARED: WritePath[] = [
 		"save",
 		"gesture",
 	),
+	w("src/lib/ai-edition/store/useTimeline.ts", "setCameraSettings", "save", "gesture"),
 	w(
 		"src/lib/ai-edition/store/useTimeline.ts",
 		"updateCameraFullscreenDeskLabel",
@@ -305,6 +317,8 @@ const DECLARED: WritePath[] = [
 		"gesture",
 	),
 	w("src/lib/ai-edition/store/useTimeline.ts", "updateCameraFullscreenSpan", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "updateCameraLayoutSpan", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "updateLayoutSlotRectLive", "set", "automatic"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "updateSpeedSpan", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "updateSpeedValue", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "updateTrim", "save", "gesture"),
diff --git a/src/lib/ai-edition/store/regionClipboard.ts b/src/lib/ai-edition/store/regionClipboard.ts
index f0d6d7d10..23be557cd 100644
--- a/src/lib/ai-edition/store/regionClipboard.ts
+++ b/src/lib/ai-edition/store/regionClipboard.ts
@@ -11,6 +11,7 @@ export type RegionSnapshot =
 	| { kind: "annotation"; region: Record<string, unknown> }
 	| { kind: "speed"; region: Record<string, unknown> }
 	| { kind: "cameraFullscreen"; region: Record<string, unknown> }
+	| { kind: "cameraLayout"; region: Record<string, unknown> }
 	// An audio track copies its whole payload (asset, gain, fades, loop) so a
 	// paste is a second placement of the same audio, like every other kind. The
 	// snapshot is the COLLAPSED pill, never a stored fragment.
diff --git a/src/lib/ai-edition/store/regionClipboardKinds.test.ts b/src/lib/ai-edition/store/regionClipboardKinds.test.ts
new file mode 100644
index 000000000..40aa00a6d
--- /dev/null
+++ b/src/lib/ai-edition/store/regionClipboardKinds.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import {
+	copySourceKey,
+	pasteHitsCameraSection,
+	pasteIdPrefix,
+	pasteTarget,
+} from "./regionClipboardKinds";
+
+describe("regionClipboardKinds", () => {
+	it("copies a layout pill from the layout list, never from Full Camera", () => {
+		expect(copySourceKey("cameraLayout")).toBe("cameraLayoutRegions");
+		expect(copySourceKey("cameraFullscreen")).toBe("cameraFullscreenRegions");
+	});
+
+	it("pastes a layout region into the layout list", () => {
+		expect(pasteTarget("cameraLayout")).toEqual({ store: "legacy", key: "cameraLayoutRegions" });
+		expect(pasteTarget("cameraFullscreen")).toEqual({
+			store: "legacy",
+			key: "cameraFullscreenRegions",
+		});
+		expect(pasteTarget("speed")).toEqual({ store: "legacy", key: "speedRegions" });
+	});
+
+	it("maps every other kind to its own place or to null", () => {
+		expect(copySourceKey("zoom")).toBe("zoomRegions");
+		expect(copySourceKey("annotation")).toBe("annotationRegions");
+		expect(copySourceKey("speed")).toBe("speedRegions");
+		expect(pasteTarget("zoom")).toEqual({ store: "document", key: "zoomRanges" });
+		expect(pasteTarget("annotation")).toEqual({ store: "document", key: "annotations" });
+		expect(pasteTarget("trim")).toBeNull();
+		expect(pasteTarget("audio")).toBeNull();
+		expect(copySourceKey("trim")).toBeNull();
+		expect(copySourceKey("audio")).toBeNull();
+	});
+
+	it("builds id prefixes", () => {
+		expect(pasteIdPrefix("cameraLayout")).toBe("camlayout");
+		expect(pasteIdPrefix("annotation")).toBe("ann");
+		expect(pasteIdPrefix("speed")).toBe("speed");
+	});
+
+	describe("pasteHitsCameraSection", () => {
+		const legacy = {
+			cameraFullscreenRegions: [{ startMs: 0, endMs: 1000 }],
+			cameraLayoutRegions: [{ startMs: 2000, endMs: 3000 }],
+		};
+
+		it("lets a Full Camera paste merge with a Full Camera region", () => {
+			expect(pasteHitsCameraSection(legacy, "cameraFullscreenRegions", 500, 1500)).toBe(false);
+		});
+
+		it("refuses a Full Camera paste over a layout section", () => {
+			expect(pasteHitsCameraSection(legacy, "cameraFullscreenRegions", 2500, 3500)).toBe(true);
+		});
+
+		it("refuses a layout paste over either list", () => {
+			expect(pasteHitsCameraSection(legacy, "cameraLayoutRegions", 500, 1500)).toBe(true);
+			expect(pasteHitsCameraSection(legacy, "cameraLayoutRegions", 2500, 3500)).toBe(true);
+			expect(pasteHitsCameraSection(legacy, "cameraLayoutRegions", 3000, 4000)).toBe(false);
+		});
+	});
+});
diff --git a/src/lib/ai-edition/store/regionClipboardKinds.ts b/src/lib/ai-edition/store/regionClipboardKinds.ts
new file mode 100644
index 000000000..a7afc392d
--- /dev/null
+++ b/src/lib/ai-edition/store/regionClipboardKinds.ts
@@ -0,0 +1,89 @@
+// Where each copyable region kind lives, so copy and paste never guess: an unsupported kind
+// maps to `null` instead of falling through into another kind's list.
+
+import { cameraSectionsOverlapping } from "@/lib/cameraLayouts";
+import type { RegionSnapshot } from "./regionClipboard";
+
+export type RegionKindName = RegionSnapshot["kind"];
+
+/** The `useTimeline` array a selected pill of this kind is copied from. */
+export type CopySourceKey =
+	| "zoomRegions"
+	| "annotationRegions"
+	| "speedRegions"
+	| "cameraFullscreenRegions"
+	| "cameraLayoutRegions";
+
+export function copySourceKey(kind: RegionKindName): CopySourceKey | null {
+	switch (kind) {
+		case "zoom":
+			return "zoomRegions";
+		case "annotation":
+			return "annotationRegions";
+		case "speed":
+			return "speedRegions";
+		case "cameraFullscreen":
+			return "cameraFullscreenRegions";
+		case "cameraLayout":
+			return "cameraLayoutRegions";
+		case "trim":
+		case "audio":
+			return null;
+	}
+}
+
+/** Where a pasted region is appended: a top-level document array, or a legacyEditor list. */
+export type PasteTarget =
+	| { store: "document"; key: "zoomRanges" | "annotations" }
+	| {
+			store: "legacy";
+			key: "speedRegions" | "cameraFullscreenRegions" | "cameraLayoutRegions";
+	  };
+
+export function pasteTarget(kind: RegionKindName): PasteTarget | null {
+	switch (kind) {
+		case "zoom":
+			return { store: "document", key: "zoomRanges" };
+		case "annotation":
+			return { store: "document", key: "annotations" };
+		case "speed":
+			return { store: "legacy", key: "speedRegions" };
+		case "cameraFullscreen":
+			return { store: "legacy", key: "cameraFullscreenRegions" };
+		case "cameraLayout":
+			return { store: "legacy", key: "cameraLayoutRegions" };
+		case "trim":
+		case "audio":
+			return null;
+	}
+}
+
+/** The id prefix for a pasted row of this kind. */
+export function pasteIdPrefix(kind: RegionKindName): string {
+	if (kind === "annotation") return "ann";
+	if (kind === "cameraLayout") return "camlayout";
+	return kind;
+}
+
+type Span = Array<{ startMs: number; endMs: number }>;
+
+/**
+ * Whether a pasted camera section lands on one it may not share the lane with. Layout sections
+ * and Full Camera regions share one lane, so a layout paste is refused over either list. A Full
+ * Camera paste is refused over layout sections only: over another Full Camera it merges, as an
+ * add does.
+ */
+export function pasteHitsCameraSection(
+	legacy: Record<string, unknown>,
+	key: "cameraFullscreenRegions" | "cameraLayoutRegions",
+	startMs: number,
+	endMs: number,
+): boolean {
+	const rows = [
+		...((legacy.cameraLayoutRegions as Span | undefined) ?? []),
+		...(key === "cameraLayoutRegions"
+			? ((legacy.cameraFullscreenRegions as Span | undefined) ?? [])
+			: []),
+	];
+	return cameraSectionsOverlapping(rows, startMs, endMs).length > 0;
+}
diff --git a/src/lib/ai-edition/store/useTimeline.test.ts b/src/lib/ai-edition/store/useTimeline.test.ts
index 2b2ae4830..2921014da 100644
--- a/src/lib/ai-edition/store/useTimeline.test.ts
+++ b/src/lib/ai-edition/store/useTimeline.test.ts
@@ -1,6 +1,7 @@
 // @vitest-environment jsdom
 import { act, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { CameraPerspective } from "@/components/video-editor/types";
 import { I18nProvider } from "@/contexts/I18nContext";
 import { DEFAULT_TEXT_PLATE } from "../annotations/background";
 import { type RegionKind, readSpeedRegions } from "../document/timeline";
@@ -749,17 +750,26 @@ describe("useTimeline.clearTimeline", () => {
 		annotation: (tl) => tl.addAnnotation(),
 		speed: (tl) => tl.addSpeed(),
 		cameraFullscreen: (tl) => tl.addCameraFullscreen(),
+		// The lane is shared with Full Camera, so the section goes after it, not over it.
+		cameraLayout: (tl) => {
+			useProjectStore.setState({ currentTimeSec: 5 });
+			return tl.addCameraLayout("screen-pip", [0]);
+		},
 	};
 	const editKinds = Object.keys(addOf) as EditKind[];
 
 	const regionCounts = (doc: AxcutDocument | null | undefined): Record<EditKind, number> => {
-		const legacy = (doc?.legacyEditor ?? {}) as { cameraFullscreenRegions?: unknown[] };
+		const legacy = (doc?.legacyEditor ?? {}) as {
+			cameraFullscreenRegions?: unknown[];
+			cameraLayoutRegions?: unknown[];
+		};
 		return {
 			zoom: doc?.zoomRanges.length ?? 0,
 			trim: doc?.timeline.trimRanges.length ?? 0,
 			annotation: doc?.annotations.length ?? 0,
 			speed: doc ? readSpeedRegions(doc).length : 0,
 			cameraFullscreen: legacy.cameraFullscreenRegions?.length ?? 0,
+			cameraLayout: legacy.cameraLayoutRegions?.length ?? 0,
 		};
 	};
 	const noRegions: Record<EditKind, number> = {
@@ -768,6 +778,7 @@ describe("useTimeline.clearTimeline", () => {
 		annotation: 0,
 		speed: 0,
 		cameraFullscreen: 0,
+		cameraLayout: 0,
 	};
 
 	// A project holding everything that is NOT an edit: two clips, a webcam, an imported
@@ -927,6 +938,7 @@ describe("useTimeline.clearTimeline", () => {
 			annotation: 1,
 			speed: 1,
 			cameraFullscreen: 1,
+			cameraLayout: 1,
 		});
 
 		await act(async () => {
@@ -966,6 +978,7 @@ describe("useTimeline.clearTimeline", () => {
 			annotation: 1,
 			speed: 1,
 			cameraFullscreen: 1,
+			cameraLayout: 1,
 		});
 
 		act(() => {
@@ -2668,3 +2681,480 @@ describe("useTimeline.updateCameraFullscreenOrientation", () => {
 		expect(stored()?.map((r) => r.rotation)).toEqual([180, 180, undefined]);
 	});
 });
+
+describe("useTimeline camera layouts", () => {
+	const camAsset = {
+		...sampleDoc.assets[0],
+		cameraTrack: {
+			sourcePath: "/tmp/camera.webm",
+			startMs: 0,
+			offsetMs: 0,
+			visible: true,
+			width: 1280,
+			height: 720,
+		},
+	};
+	const clipA = sampleDoc.timeline.clips[0];
+	type Rect = { x: number; y: number; width: number; height: number };
+	const fullRow = (id: string, startMs: number, endMs: number) => ({
+		id,
+		startMs,
+		endMs,
+		clipId: clipA.id,
+		assetId: clipA.assetId,
+		sourceStartSec: startMs / 1000,
+		sourceEndSec: endMs / 1000,
+	});
+	const layoutRow = (
+		id: string,
+		startMs: number,
+		endMs: number,
+		template: string,
+		slots: Array<{ camera: number; rect?: Rect }>,
+	) => ({ ...fullRow(id, startMs, endMs), template, slots });
+
+	const seed = (legacy: Record<string, unknown> | null) => {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: { ...sampleDoc, assets: [camAsset], legacyEditor: legacy },
+			currentTimeSec: 1,
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+	};
+	const legacyNow = () =>
+		(useProjectStore.getState().document?.legacyEditor ?? {}) as {
+			cameraFullscreenRegions?: Array<Record<string, unknown>>;
+			cameraLayoutRegions?: Array<Record<string, unknown>>;
+		};
+
+	beforeEach(() => {
+		useProjectStore.getState().clear();
+		clearHistory();
+		for (const mock of Object.values(bridgeMocks)) mock.mockReset();
+		bridgeMocks.save.mockImplementation(async (doc: typeof sampleDoc) => ({
+			success: true,
+			document: doc,
+		}));
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("adds a screen-pip section at the playhead", async () => {
+		seed(null);
+		const { result } = renderTimeline();
+		let outcome: string | undefined;
+		await act(async () => {
+			outcome = await result.current.addCameraLayout("screen-pip", [0]);
+		});
+		expect(outcome).toBe("added");
+		expect(past).toHaveLength(1);
+		expect(result.current.cameraLayoutRegions).toHaveLength(1);
+		expect(result.current.cameraLayoutRegions[0]).toMatchObject({
+			startMs: 1000,
+			endMs: 3000,
+			template: "screen-pip",
+			slots: [{ camera: 0 }],
+			clipId: "clip_a",
+		});
+		expect(result.current.cameraLayoutRegions[0].id.startsWith("camlayout")).toBe(true);
+	});
+
+	it("refuses a section when no clip has a camera", async () => {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: sampleDoc,
+			currentTimeSec: 1,
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+		const { result } = renderTimeline();
+		let outcome: string | undefined;
+		await act(async () => {
+			outcome = await result.current.addCameraLayout("screen-pip", [0]);
+		});
+		expect(outcome).toBe("no-camera");
+		expect(bridgeMocks.save).not.toHaveBeenCalled();
+	});
+
+	it("adding over a full camera region is refused", async () => {
+		seed({ cameraFullscreenRegions: [fullRow("camfull_1", 2000, 4000)] });
+		const before = useProjectStore.getState().document;
+		const { result } = renderTimeline();
+		let outcome: string | undefined;
+		await act(async () => {
+			outcome = await result.current.addCameraLayout("screen-pip", [0]);
+		});
+		expect(outcome).toBe("occupied");
+		expect(bridgeMocks.save).not.toHaveBeenCalled();
+		expect(useProjectStore.getState().document).toBe(before);
+	});
+
+	it("adding a full camera region over a layout section is refused", async () => {
+		seed({
+			cameraLayoutRegions: [layoutRow("camlayout_1", 2000, 4000, "screen-pip", [{ camera: 0 }])],
+		});
+		const { result } = renderTimeline();
+		let outcome: string | undefined;
+		await act(async () => {
+			outcome = await result.current.addCameraFullscreen();
+		});
+		expect(outcome).toBe("occupied");
+		expect(bridgeMocks.save).not.toHaveBeenCalled();
+	});
+
+	it("camera-full with camera 1 is added as a full camera region", async () => {
+		seed(null);
+		const { result } = renderTimeline();
+		let outcome: string | undefined;
+		await act(async () => {
+			outcome = await result.current.addCameraLayout("camera-full", [0]);
+		});
+		expect(outcome).toBe("added");
+		expect(result.current.cameraLayoutRegions).toEqual([]);
+		expect(result.current.cameraFullscreenRegions).toHaveLength(1);
+		expect(result.current.cameraFullscreenRegions[0]).toMatchObject({
+			startMs: 1000,
+			endMs: 3000,
+		});
+	});
+
+	it("moving a layout section clamps at a full camera neighbour", async () => {
+		seed({
+			cameraFullscreenRegions: [fullRow("camfull_1", 5000, 7000)],
+			cameraLayoutRegions: [layoutRow("camlayout_1", 1000, 3000, "screen-pip", [{ camera: 0 }])],
+		});
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.updateCameraLayoutSpan("camlayout_1", 1000, 6000);
+		});
+		const rows = result.current.cameraLayoutRegions;
+		expect(rows).toHaveLength(1);
+		expect(rows[0]).toMatchObject({ startMs: 1000, endMs: 5000 });
+		expect(result.current.cameraFullscreenRegions[0]).toMatchObject({
+			startMs: 5000,
+			endMs: 7000,
+		});
+	});
+
+	it("moving a full camera region clamps at a layout neighbour", async () => {
+		seed({
+			cameraFullscreenRegions: [fullRow("camfull_1", 1000, 3000)],
+			cameraLayoutRegions: [layoutRow("camlayout_1", 5000, 7000, "screen-pip", [{ camera: 0 }])],
+		});
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.updateCameraFullscreenSpan("camfull_1", 1000, 6000);
+		});
+		expect(result.current.cameraFullscreenRegions[0]).toMatchObject({
+			startMs: 1000,
+			endMs: 5000,
+		});
+	});
+
+	it("switching a full camera section to camera-full-pip moves it to the layout list in one undo step", async () => {
+		seed({
+			cameraFullscreenRegions: [{ ...fullRow("camfull_1", 1000, 3000), rotation: 180 }],
+		});
+		const before = useProjectStore.getState().document;
+		const { result } = renderTimeline();
+		let handle: { kind: string; id: string } | undefined;
+		await act(async () => {
+			handle = await result.current.setLayoutTemplate(
+				{ kind: "cameraFullscreen", id: "camfull_1" },
+				"camera-full-pip",
+				[0, 1],
+			);
+		});
+		expect(bridgeMocks.save).toHaveBeenCalledTimes(1);
+		expect(past).toHaveLength(1);
+		expect(handle?.kind).toBe("cameraLayout");
+		expect(legacyNow().cameraFullscreenRegions).toEqual([]);
+		const rows = legacyNow().cameraLayoutRegions ?? [];
+		expect(rows).toHaveLength(1);
+		expect(rows[0]).toMatchObject({
+			id: handle?.id,
+			startMs: 1000,
+			endMs: 3000,
+			clipId: "clip_a",
+			sourceStartSec: 1,
+			sourceEndSec: 3,
+			template: "camera-full-pip",
+			slots: [{ camera: 0 }, { camera: 1 }],
+		});
+		// Ruling R1: the desk fields stay behind.
+		expect(rows[0]).not.toHaveProperty("rotation");
+		act(() => {
+			expect(undo()).toBe(true);
+		});
+		expect(useProjectStore.getState().document).toEqual(before);
+	});
+
+	it("switching back to camera-full with camera 1 restores a full camera region", async () => {
+		seed({
+			cameraLayoutRegions: [
+				layoutRow("camlayout_1", 1000, 3000, "camera-full-pip", [{ camera: 0 }, { camera: 1 }]),
+			],
+		});
+		const { result } = renderTimeline();
+		let handle: { kind: string; id: string } | undefined;
+		await act(async () => {
+			handle = await result.current.setLayoutTemplate(
+				{ kind: "cameraLayout", id: "camlayout_1" },
+				"camera-full",
+				[0],
+			);
+		});
+		expect(handle?.kind).toBe("cameraFullscreen");
+		expect(legacyNow().cameraLayoutRegions).toEqual([]);
+		expect(legacyNow().cameraFullscreenRegions).toEqual([fullRow(handle?.id ?? "", 1000, 3000)]);
+	});
+
+	it("switching a layout section to another layout template keeps its cameras", async () => {
+		seed({
+			cameraLayoutRegions: [layoutRow("camlayout_1", 1000, 3000, "screen-pip", [{ camera: 1 }])],
+		});
+		const { result } = renderTimeline();
+		let handle: { kind: string; id: string } | undefined;
+		await act(async () => {
+			handle = await result.current.setLayoutTemplate(
+				{ kind: "cameraLayout", id: "camlayout_1" },
+				"side-by-side",
+				[0, 1],
+			);
+		});
+		expect(handle).toEqual({ kind: "cameraLayout", id: "camlayout_1" });
+		expect(legacyNow().cameraLayoutRegions?.[0]).toMatchObject({
+			template: "side-by-side",
+			slots: [{ camera: 1 }, { camera: 0 }],
+		});
+	});
+
+	it("choosing a camera already in the section swaps the two places", async () => {
+		seed({
+			cameraLayoutRegions: [
+				layoutRow("camlayout_1", 1000, 3000, "side-by-side", [{ camera: 0 }, { camera: 1 }]),
+			],
+		});
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.setLayoutSlotCamera({ kind: "cameraLayout", id: "camlayout_1" }, 0, 1);
+		});
+		expect(legacyNow().cameraLayoutRegions?.[0].slots).toEqual([{ camera: 1 }, { camera: 0 }]);
+	});
+
+	it("refuses a template that needs more cameras than were given", async () => {
+		seed(null);
+		const { result } = renderTimeline();
+		let outcome: string | undefined;
+		await act(async () => {
+			outcome = await result.current.addCameraLayout("side-by-side", [0]);
+		});
+		expect(outcome).toBe("too-few-cameras");
+		expect(bridgeMocks.save).not.toHaveBeenCalled();
+	});
+
+	it("choosing camera 2 for a full camera section turns it into camera-full of camera 2 in one undo step", async () => {
+		seed({
+			cameraFullscreenRegions: [{ ...fullRow("camfull_1", 1000, 3000), rotation: 180 }],
+		});
+		const before = useProjectStore.getState().document;
+		const { result } = renderTimeline();
+		let handle: { kind: string; id: string } | undefined;
+		await act(async () => {
+			handle = await result.current.setLayoutSlotCamera(
+				{ kind: "cameraFullscreen", id: "camfull_1" },
+				0,
+				1,
+			);
+		});
+		expect(bridgeMocks.save).toHaveBeenCalledTimes(1);
+		expect(past).toHaveLength(1);
+		expect(handle?.kind).toBe("cameraLayout");
+		expect(legacyNow().cameraFullscreenRegions).toEqual([]);
+		expect(legacyNow().cameraLayoutRegions).toEqual([
+			{ ...fullRow(handle?.id ?? "", 1000, 3000), template: "camera-full", slots: [{ camera: 1 }] },
+		]);
+		act(() => {
+			expect(undo()).toBe(true);
+		});
+		expect(useProjectStore.getState().document).toEqual(before);
+	});
+
+	it("choosing camera 1 for a full camera section again is a no-op", async () => {
+		seed({ cameraFullscreenRegions: [fullRow("camfull_1", 1000, 3000)] });
+		const { result } = renderTimeline();
+		let handle: { kind: string; id: string } | undefined;
+		await act(async () => {
+			handle = await result.current.setLayoutSlotCamera(
+				{ kind: "cameraFullscreen", id: "camfull_1" },
+				0,
+				0,
+			);
+		});
+		expect(handle).toEqual({ kind: "cameraFullscreen", id: "camfull_1" });
+		expect(bridgeMocks.save).not.toHaveBeenCalled();
+	});
+
+	it("a slot rect drag is one undo step", async () => {
+		seed({
+			cameraLayoutRegions: [layoutRow("camlayout_1", 1000, 3000, "screen-pip", [{ camera: 0 }])],
+		});
+		const before = useProjectStore.getState().document;
+		const { result } = renderTimeline();
+		act(() => {
+			result.current.updateLayoutSlotRectLive("camlayout_1", 0, {
+				x: 0.1,
+				y: 0.1,
+				width: 0.2,
+				height: 0.2,
+			});
+		});
+		act(() => {
+			result.current.updateLayoutSlotRectLive("camlayout_1", 0, {
+				x: 0.3,
+				y: 0.3,
+				width: 0.2,
+				height: 0.2,
+			});
+		});
+		expect(bridgeMocks.save).not.toHaveBeenCalled();
+		await act(async () => {
+			await result.current.commitLayoutSlotRect();
+		});
+		expect(bridgeMocks.save).toHaveBeenCalledTimes(1);
+		expect(past).toHaveLength(1);
+		expect(legacyNow().cameraLayoutRegions?.[0].slots).toEqual([
+			{ camera: 0, rect: { x: 0.3, y: 0.3, width: 0.2, height: 0.2 } },
+		]);
+		act(() => {
+			expect(undo()).toBe(true);
+		});
+		expect(useProjectStore.getState().document).toEqual(before);
+	});
+
+	it("reset removes every slot rect", async () => {
+		const rect = { x: 0.1, y: 0.1, width: 0.2, height: 0.2 };
+		seed({
+			cameraLayoutRegions: [
+				layoutRow("camlayout_1", 1000, 3000, "side-by-side", [
+					{ camera: 0, rect },
+					{ camera: 1, rect },
+				]),
+			],
+		});
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.resetLayoutSlotRects("camlayout_1");
+		});
+		expect(legacyNow().cameraLayoutRegions?.[0].slots).toEqual([{ camera: 0 }, { camera: 1 }]);
+	});
+
+	it("removes layout sections in a batch removal", async () => {
+		seed({
+			cameraFullscreenRegions: [fullRow("camfull_1", 5000, 7000)],
+			cameraLayoutRegions: [layoutRow("camlayout_1", 1000, 3000, "screen-pip", [{ camera: 0 }])],
+		});
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.removeRegions([
+				{ kind: "cameraLayout", id: "camlayout_1" },
+				{ kind: "cameraFullscreen", id: "camfull_1" },
+			]);
+		});
+		expect(legacyNow().cameraLayoutRegions).toEqual([]);
+		expect(legacyNow().cameraFullscreenRegions).toEqual([]);
+	});
+});
+
+describe("useTimeline.setCameraSettings", () => {
+	const stored = () =>
+		(useProjectStore.getState().document?.legacyEditor ?? {}) as { cameraSettings?: unknown };
+
+	function seed(legacyEditor: Record<string, unknown> | null) {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: { ...sampleDoc, legacyEditor },
+			currentTimeSec: 1,
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+	}
+
+	it("setting camera 2 mirror stores only that", async () => {
+		seed({});
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.setCameraSettings(1, { mirror: true });
+		});
+		expect(stored().cameraSettings).toEqual([null, { mirror: true }]);
+	});
+
+	it("a queued second write builds on the first, not on the render's document", async () => {
+		seed({});
+		const { result } = renderTimeline();
+		// One callback from one render, called twice in a row: the shell's write queue runs
+		// them back to back, before React re-renders with the first save.
+		const set = result.current.setCameraSettings;
+		await act(async () => {
+			await set(1, { mirror: true });
+			await set(2, { rotation: 180 });
+		});
+		expect(stored().cameraSettings).toEqual([null, { mirror: true }, { rotation: 180 }]);
+	});
+
+	it("resetting the last camera removes the key", async () => {
+		seed({ other: 1, cameraSettings: [null, { mirror: true }] });
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.setCameraSettings(1, null);
+		});
+		expect(stored()).toEqual({ other: 1 });
+		act(() => {
+			expect(undo()).toBe(true);
+		});
+		expect(stored().cameraSettings).toEqual([null, { mirror: true }]);
+	});
+
+	it("a patch that changes nothing writes nothing", async () => {
+		seed(null);
+		bridgeMocks.save.mockClear();
+		const { result } = renderTimeline();
+		const before = useProjectStore.getState().document;
+		await act(async () => {
+			await result.current.setCameraSettings(9, { mirror: true });
+			await result.current.setCameraSettings(0, { mirror: true });
+			await result.current.setCameraSettings(1, null);
+		});
+		expect(useProjectStore.getState().document).toBe(before);
+		expect(useProjectStore.getState().document?.legacyEditor).toBeNull();
+		expect(bridgeMocks.save).not.toHaveBeenCalled();
+	});
+
+	it("camera 1 accepts only a perspective", async () => {
+		seed({});
+		const { result } = renderTimeline();
+		await act(async () => {
+			await result.current.setCameraSettings(0, { mirror: true, rotation: 180 });
+		});
+		expect(stored().cameraSettings).toBeUndefined();
+		const perspective: CameraPerspective = {
+			corners: [
+				{ x: 0.1, y: 0.1 },
+				{ x: 0.9, y: 0.1 },
+				{ x: 0.9, y: 0.9 },
+				{ x: 0.1, y: 0.9 },
+			],
+			aspect: 1.5,
+		};
+		await act(async () => {
+			await result.current.setCameraSettings(0, { mirror: true, perspective });
+		});
+		expect(stored().cameraSettings).toEqual([{ perspective }]);
+	});
+});
diff --git a/src/lib/ai-edition/store/useTimeline.ts b/src/lib/ai-edition/store/useTimeline.ts
index e94d23203..0b48c0abb 100644
--- a/src/lib/ai-edition/store/useTimeline.ts
+++ b/src/lib/ai-edition/store/useTimeline.ts
@@ -3,16 +3,30 @@
 // speed regions. Each add creates a 2-second region at the current playhead
 // (a reasonable default for the user to then resize).
 
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { toast } from "sonner";
 import { toFileUrl } from "@/components/video-editor/projectPersistence";
 import type {
 	AnnotationRegion,
 	AnnotationType,
 	CameraFullscreenRegion,
+	CameraLayoutSlot,
+	CameraLayoutTemplate,
+	CameraSettings,
+	NormalizedRect,
 	Rotation3DPreset,
 } from "@/components/video-editor/types";
 import { useScopedT } from "@/contexts/I18nContext";
+import {
+	type AnchoredCameraLayoutRegion,
+	cameraSectionsOverlapping,
+	isFullCameraLayout,
+	MAX_CAMERAS,
+	normalizeCameraLayoutRegions,
+	normalizeCameraSettings,
+	patchCameraSettings,
+	TEMPLATE_SLOTS,
+} from "@/lib/cameraLayouts";
 import {
 	type CameraMirrorMode,
 	type CameraRotation,
@@ -50,6 +64,8 @@ import { hasAnyClipWithCamera } from "../timeline/camera";
 import { probeAudioDuration, probeVideoDimensions, probeVideoDuration } from "../timeline/duration";
 import {
 	anchorRegionsWithDerivedMs,
+	clampSpanAgainstNeighbours,
+	coalesceRegionsForRuler,
 	dropPillsByIds,
 	replacePillSpan,
 	resolvePillIds,
@@ -103,6 +119,201 @@ function patchPillById<T extends { id: string; startMs: number; endMs: number }>
 	return regions.map((r) => (under.has(r.id) ? { ...r, ...patch } : r));
 }
 
+// --- Camera sections ---------------------------------------------------------------
+// Full Camera regions and layout sections share one timeline lane but live in two lists:
+// a `camera-full` section of camera 1 is a Full Camera region, everything else a layout
+// row (see `isFullCameraLayout`). The helpers below keep the two lists disjoint in time
+// and move a section between them when its template changes.
+
+/** The anchor and derived span every stored row of both lists carries. */
+interface AnchoredRow {
+	id: string;
+	startMs: number;
+	endMs: number;
+	clipId?: string;
+	assetId?: string;
+	sourceStartSec?: number;
+	sourceEndSec?: number;
+}
+
+type FullCameraRow = CameraFullscreenRegion & AnchoredRow;
+
+/** A section on the shared camera lane, as the selection names it. */
+export interface CameraSectionHandle {
+	kind: "cameraFullscreen" | "cameraLayout";
+	id: string;
+}
+
+/** `too-few-cameras`: the project has a camera, but the template needs more than were given. */
+export type AddCameraSectionOutcome = "added" | "occupied" | "no-camera" | "too-few-cameras";
+
+interface CameraLanes {
+	legacy: Record<string, unknown>;
+	full: FullCameraRow[];
+	layout: AnchoredCameraLayoutRegion[];
+}
+
+function cameraLanes(doc: AxcutDocument): CameraLanes {
+	const legacy = (doc.legacyEditor as Record<string, unknown>) ?? {};
+	const full = (legacy.cameraFullscreenRegions as FullCameraRow[] | undefined) ?? [];
+	const layout = (legacy.cameraLayoutRegions as AnchoredCameraLayoutRegion[] | undefined) ?? [];
+	return { legacy, full, layout };
+}
+
+function withCameraLanes(
+	doc: AxcutDocument,
+	lanes: CameraLanes,
+	full: FullCameraRow[],
+	layout: AnchoredCameraLayoutRegion[],
+): AxcutDocument {
+	// A list that was never stored and is still empty stays absent, so a project that never
+	// used layout sections keeps its legacy envelope unchanged.
+	const keep = (key: string, rows: unknown[]) =>
+		rows.length > 0 || key in lanes.legacy ? { [key]: rows } : {};
+	return {
+		...doc,
+		legacyEditor: {
+			...lanes.legacy,
+			...keep("cameraFullscreenRegions", full),
+			...keep("cameraLayoutRegions", layout),
+		},
+	};
+}
+
+/** Whether the span `[startMs, endMs)` overlaps any row of either list. */
+function cameraLaneOccupied(lanes: CameraLanes, startMs: number, endMs: number): boolean {
+	return cameraSectionsOverlapping([...lanes.full, ...lanes.layout], startMs, endMs).length > 0;
+}
+
+// An identity no stored region can have, so a pill of the other list is always a wall.
+const OTHER_CAMERA_LIST = "\u0000other-camera-list";
+
+/**
+ * The span the pill holding `id` may take on the shared lane: clamped against the other
+ * pills of its own list (by the usual identity rule) and against every pill of the other
+ * list. `replacePillSpan` then applies the same-list clamp again, which is a no-op.
+ */
+function clampCameraSpan(
+	own: AnchoredRow[],
+	other: AnchoredRow[],
+	id: string,
+	startMs: number,
+	endMs: number,
+): { startMs: number; endMs: number } {
+	const pills = coalesceRegionsForRuler(own);
+	const pill = pills.find((p) => p.ids.includes(id));
+	if (!pill) return { startMs, endMs };
+	const walls = [
+		...pills
+			.filter((p) => p !== pill)
+			.map((p) => ({ id: p.ids[0], start: p.start, end: p.end, identity: p.identity })),
+		...coalesceRegionsForRuler(other).map((p) => ({
+			id: p.ids[0],
+			start: p.start,
+			end: p.end,
+			identity: OTHER_CAMERA_LIST,
+		})),
+	];
+	const clamped = clampSpanAgainstNeighbours(
+		{ start: startMs / 1000, end: endMs / 1000 },
+		pill.identity,
+		walls,
+	);
+	return { startMs: Math.round(clamped.start * 1000), endMs: Math.round(clamped.end * 1000) };
+}
+
+/** Only the anchor and span of a row: what survives a move to the other list. */
+function anchorOf(row: AnchoredRow, id: string): AnchoredRow {
+	const out: AnchoredRow = { id, startMs: row.startMs, endMs: row.endMs };
+	if (row.clipId !== undefined) out.clipId = row.clipId;
+	if (row.assetId !== undefined) out.assetId = row.assetId;
+	if (row.sourceStartSec !== undefined) out.sourceStartSec = row.sourceStartSec;
+	if (row.sourceEndSec !== undefined) out.sourceEndSec = row.sourceEndSec;
+	return out;
+}
+
+/**
+ * The cameras of a section after a template change: its own cameras in order, then the
+ * given ones it does not hold yet, cut to what the template places. `null` when the
+ * template needs more cameras than that.
+ */
+function camerasForTemplate(
+	template: CameraLayoutTemplate,
+	current: number[],
+	cameras: number[],
+): number[] | null {
+	const out: number[] = [];
+	for (const camera of [...current, ...cameras]) {
+		if (!Number.isInteger(camera) || camera < 0 || camera >= MAX_CAMERAS) continue;
+		if (!out.includes(camera)) out.push(camera);
+	}
+	const { min, max } = TEMPLATE_SLOTS[template];
+	const cut = out.slice(0, max);
+	return cut.length >= min ? cut : null;
+}
+
+/**
+ * Move the pill holding `id` from one list to the other, keeping every row's anchor and
+ * span. `toRow` builds the new row; returns the new rows and the id the moved `id` became,
+ * or `null` when no stored row has that id.
+ */
+function movePill<From extends AnchoredRow, To extends AnchoredRow>(
+	from: From[],
+	id: string,
+	prefix: string,
+	toRow: (anchor: AnchoredRow) => To,
+): { remaining: From[]; moved: To[]; newId: string } | null {
+	if (!from.some((r) => r.id === id)) return null;
+	const under = new Set(resolvePillIds(from, id));
+	let newId = id;
+	const moved: To[] = [];
+	for (const row of from) {
+		if (!under.has(row.id)) continue;
+		const rowId = createId(prefix);
+		if (row.id === id) newId = rowId;
+		moved.push(toRow(anchorOf(row, rowId)));
+	}
+	return { remaining: from.filter((r) => !under.has(r.id)), moved, newId };
+}
+
+/**
+ * The document with the Full Camera pill `id` turned into a layout section with the given
+ * template and places. The desk fields stay behind: desk view exists only on Full Camera.
+ */
+function fullCameraPillToLayout(
+	doc: AxcutDocument,
+	lanes: CameraLanes,
+	id: string,
+	template: CameraLayoutTemplate,
+	slots: CameraLayoutSlot[],
+): { doc: AxcutDocument; handle: CameraSectionHandle } | null {
+	const move = movePill(
+		lanes.full,
+		id,
+		"camlayout",
+		(anchor): AnchoredCameraLayoutRegion => ({ ...anchor, template, slots }),
+	);
+	if (!move) return null;
+	return {
+		doc: withCameraLanes(doc, lanes, move.remaining, [...lanes.layout, ...move.moved]),
+		handle: { kind: "cameraLayout", id: move.newId },
+	};
+}
+
+/** The document with the layout pill `id` turned into a Full Camera region of camera 1. */
+function layoutPillToFullCamera(
+	doc: AxcutDocument,
+	lanes: CameraLanes,
+	id: string,
+): { doc: AxcutDocument; handle: CameraSectionHandle } | null {
+	const move = movePill(lanes.layout, id, "camfull", (anchor): FullCameraRow => anchor);
+	if (!move) return null;
+	return {
+		doc: withCameraLanes(doc, lanes, [...lanes.full, ...move.moved], move.remaining),
+		handle: { kind: "cameraFullscreen", id: move.newId },
+	};
+}
+
 /**
  * Playhead position at CALL time, read imperatively — deliberately not a
  * subscription.
@@ -158,6 +369,9 @@ export function useTimeline() {
 	} | null>(null);
 	const annotationRollbackRef = useRef<AxcutDocument | null>(null);
 	const annotationLiveRef = useRef<AxcutDocument | null>(null);
+	// The same pair for dragging a place of a layout section.
+	const layoutRectRollbackRef = useRef<AxcutDocument | null>(null);
+	const layoutRectLiveRef = useRef<AxcutDocument | null>(null);
 
 	// A drag does not always end in a commit: `ZoomFocusOverlay` unmounts the moment
 	// `focusMode` flips to "auto", so `endDrag` never runs and the snapshot outlives the
@@ -172,6 +386,8 @@ export function useTimeline() {
 		zoomFocusEditRef.current = null;
 		annotationRollbackRef.current = null;
 		annotationLiveRef.current = null;
+		layoutRectRollbackRef.current = null;
+		layoutRectLiveRef.current = null;
 	}, [projectId]);
 
 	const hasDoc = document !== null && projectId !== null;
@@ -544,18 +760,23 @@ export function useTimeline() {
 	// entry points — the toolbar and the `C` shortcut — and any future one are covered
 	// by construction. `hasAnyClipWithCamera` is the consolidated answer to "does this
 	// project have a camera at all", used the same way by the Layout pane.
+	//
+	// The lane is shared with layout sections, and those two lists never overlap: a span
+	// that would land on a layout section is refused ("occupied") and nothing is written.
+	// Over another Full Camera region it still writes, and the two merge on display.
 	const addCameraFullscreen = useCallback(
-		async (durationSec = DEFAULT_NEW_REGION_SEC) => {
-			if (!document) return;
-			if (!hasAnyClipWithCamera(document.assets, document.timeline.clips)) return;
+		async (durationSec = DEFAULT_NEW_REGION_SEC): Promise<AddCameraSectionOutcome> => {
+			if (!document) return "no-camera";
+			if (!hasAnyClipWithCamera(document.assets, document.timeline.clips)) return "no-camera";
 			const timeMs = Math.round(playheadSec() * 1000);
 			const endMs = timeMs + Math.round(durationSec * 1000);
-			const legacy = (document.legacyEditor as Record<string, unknown>) ?? {};
-			const prev = (legacy.cameraFullscreenRegions as unknown[]) ?? [];
+			const lanes = cameraLanes(document);
+			if (cameraSectionsOverlapping(lanes.layout, timeMs, endMs).length > 0) return "occupied";
+			const prev = (lanes.legacy.cameraFullscreenRegions as unknown[]) ?? [];
 			const next: AxcutDocument = {
 				...document,
 				legacyEditor: {
-					...legacy,
+					...lanes.legacy,
 					cameraFullscreenRegions: [
 						...prev,
 						...anchorRegionsWithDerivedMs(
@@ -567,10 +788,43 @@ export function useTimeline() {
 				},
 			};
 			await saveDocument(next, { history: true });
+			return "added";
 		},
 		[document, saveDocument],
 	);
 
+	// A layout section at the playhead, with the same camera gate and default duration as
+	// Full Camera. Unlike Full Camera it refuses any overlap on the shared lane, so the
+	// caller can tell the user the spot is taken. `camera-full` of camera 1 IS a Full
+	// Camera region and is added as one.
+	const addCameraLayout = useCallback(
+		async (
+			template: CameraLayoutTemplate,
+			cameras: number[],
+			durationSec = DEFAULT_NEW_REGION_SEC,
+		): Promise<AddCameraSectionOutcome> => {
+			if (!document) return "no-camera";
+			if (!hasAnyClipWithCamera(document.assets, document.timeline.clips)) return "no-camera";
+			const picked = camerasForTemplate(template, [], cameras);
+			if (!picked) return "too-few-cameras";
+			const slots: CameraLayoutSlot[] = picked.map((camera) => ({ camera }));
+			const timeMs = Math.round(playheadSec() * 1000);
+			const endMs = timeMs + Math.round(durationSec * 1000);
+			const lanes = cameraLanes(document);
+			if (cameraLaneOccupied(lanes, timeMs, endMs)) return "occupied";
+			if (isFullCameraLayout({ template, slots })) return addCameraFullscreen(durationSec);
+			const added = anchorRegionsWithDerivedMs<AnchoredCameraLayoutRegion>(
+				[{ id: createId("camlayout"), startMs: timeMs, endMs, template, slots }],
+				document.timeline.clips,
+				() => createId("camlayout"),
+			);
+			const next = withCameraLanes(document, lanes, lanes.full, [...lanes.layout, ...added]);
+			await saveDocument(next, { history: true });
+			return "added";
+		},
+		[addCameraFullscreen, document, saveDocument],
+	);
+
 	// Like updateTrimRange but also re-attaches the trim to a (possibly different) CLIP —
 	// needed when a trim is dragged across a clip boundary, whether or not the landing clip
 	// is backed by another asset. Re-pointing `clipId` as well as `assetId` is what makes a
@@ -1029,26 +1283,23 @@ export function useTimeline() {
 		[document, saveDocument],
 	);
 
+	// Move/resize on the shared camera lane: clamped at the pills of both lists.
 	const updateCameraFullscreenSpan = useCallback(
 		async (id: string, startMs: number, endMs: number) => {
 			if (!document) return;
 			const s = finiteMs(startMs);
 			const e = finiteMs(endMs);
-			const legacy = (document.legacyEditor as Record<string, unknown>) ?? {};
-			const prev = ((legacy.cameraFullscreenRegions as unknown[]) ?? []) as Array<{
-				id: string;
-				startMs: number;
-				endMs: number;
-			}>;
+			const lanes = cameraLanes(document);
+			const span = clampCameraSpan(lanes.full, lanes.layout, id, Math.min(s, e), Math.max(s, e));
 			const next: AxcutDocument = {
 				...document,
 				legacyEditor: {
-					...legacy,
+					...lanes.legacy,
 					cameraFullscreenRegions: replacePillSpan(
-						prev,
+						lanes.full,
 						id,
-						Math.min(s, e),
-						Math.max(s, e),
+						span.startMs,
+						span.endMs,
 						document.timeline.clips,
 						() => createId("camfull"),
 					),
@@ -1059,6 +1310,26 @@ export function useTimeline() {
 		[document, saveDocument],
 	);
 
+	const updateCameraLayoutSpan = useCallback(
+		async (id: string, startMs: number, endMs: number) => {
+			if (!document) return;
+			const s = finiteMs(startMs);
+			const e = finiteMs(endMs);
+			const lanes = cameraLanes(document);
+			const span = clampCameraSpan(lanes.layout, lanes.full, id, Math.min(s, e), Math.max(s, e));
+			const layout = replacePillSpan(
+				lanes.layout,
+				id,
+				span.startMs,
+				span.endMs,
+				document.timeline.clips,
+				() => createId("camlayout"),
+			);
+			await saveDocument(withCameraLanes(document, lanes, lanes.full, layout), { history: true });
+		},
+		[document, saveDocument],
+	);
+
 	const updateSpeedValue = useCallback(
 		async (id: string, speed: number) => {
 			if (!document) return;
@@ -1110,6 +1381,33 @@ export function useTimeline() {
 		[document, saveDocument],
 	);
 
+	// Per-camera settings (`legacyEditor.cameraSettings`). One write, one undo step; the key
+	// is deleted when nothing is left, so untouched projects stay byte-identical.
+	// The document is read when the write runs, not when the callback was made: callers put
+	// it on the shell's write queue, and a queued write must build on the save before it.
+	const setCameraSettings = useCallback(
+		async (index: number, patch: Partial<CameraSettings> | null) => {
+			const current = useProjectStore.getState().document ?? document;
+			if (!current) return;
+			const legacy = (current.legacyEditor as Record<string, unknown>) ?? {};
+			const list = patchCameraSettings(legacy.cameraSettings, index, patch);
+			// Nothing changes (out-of-range index, camera-1 patch without a perspective, resetting a
+			// default camera): no save and no empty undo step.
+			if (
+				JSON.stringify(list ?? []) ===
+				JSON.stringify(normalizeCameraSettings(legacy.cameraSettings))
+			)
+				return;
+			const { cameraSettings: _prev, ...rest } = legacy;
+			const next: AxcutDocument = {
+				...current,
+				legacyEditor: list ? { ...rest, cameraSettings: list } : rest,
+			};
+			await saveDocument(next, { history: true });
+		},
+		[document, saveDocument],
+	);
+
 	const updateCameraFullscreenDeskLabel = useCallback(
 		async (id: string, show: boolean) => {
 			if (!document) return;
@@ -1131,6 +1429,154 @@ export function useTimeline() {
 		[document, saveDocument],
 	);
 
+	// Change the template of a section on the camera lane, in ONE save, so one undo step.
+	// The storage rule decides the list: a `camera-full` section of camera 1 is a Full
+	// Camera region, everything else a layout row. A switch that crosses that line moves
+	// the section's rows to the other list on the same anchors; a Full Camera section's
+	// desk fields stay behind (desk view exists only there), and a section coming back gets
+	// the default desk fields. Returns the section's handle afterwards, so the selection can
+	// follow it to the other list — or the given handle when nothing was written.
+	const setLayoutTemplate = useCallback(
+		async (
+			handle: CameraSectionHandle,
+			template: CameraLayoutTemplate,
+			cameras: number[],
+		): Promise<CameraSectionHandle> => {
+			if (!document) return handle;
+			const lanes = cameraLanes(document);
+			const current =
+				handle.kind === "cameraFullscreen"
+					? [0]
+					: (lanes.layout.find((r) => r.id === handle.id)?.slots.map((s) => s.camera) ?? []);
+			const picked = camerasForTemplate(template, current, cameras);
+			if (!picked) return handle;
+			const slots: CameraLayoutSlot[] = picked.map((camera) => ({ camera }));
+			const toFullCamera = isFullCameraLayout({ template, slots });
+			let result: { doc: AxcutDocument; handle: CameraSectionHandle } | null = null;
+			if (handle.kind === "cameraFullscreen") {
+				if (toFullCamera) return handle;
+				result = fullCameraPillToLayout(document, lanes, handle.id, template, slots);
+			} else if (toFullCamera) {
+				result = layoutPillToFullCamera(document, lanes, handle.id);
+			} else {
+				const member = lanes.layout.find((r) => r.id === handle.id);
+				if (!member || member.template === template) return handle;
+				// A place's own rect belongs to the old template's arrangement, so it goes.
+				const layout = patchPillById(lanes.layout, handle.id, { template, slots });
+				result = { doc: withCameraLanes(document, lanes, lanes.full, layout), handle };
+			}
+			if (!result) return handle;
+			return (await saveDocument(result.doc, { history: true })) ? result.handle : handle;
+		},
+		[document, saveDocument],
+	);
+
+	// Put `camera` in place `slotIndex` of a layout section. A camera shows once per
+	// section, so if it already has another place the two swap; each place keeps its rect.
+	// A `camera-full` section that ends up showing camera 1 becomes a Full Camera region,
+	// and a Full Camera region given another camera becomes that camera's `camera-full`
+	// section. Returns the section's handle afterwards, or the given one when nothing changed.
+	const setLayoutSlotCamera = useCallback(
+		async (
+			handle: CameraSectionHandle,
+			slotIndex: number,
+			camera: number,
+		): Promise<CameraSectionHandle> => {
+			if (!document) return handle;
+			if (!Number.isInteger(camera) || camera < 0 || camera >= MAX_CAMERAS) return handle;
+			const lanes = cameraLanes(document);
+			if (handle.kind === "cameraFullscreen") {
+				// Its one place shows camera 1; choosing camera 1 again changes nothing.
+				if (slotIndex !== 0 || camera === 0) return handle;
+				const moved = fullCameraPillToLayout(document, lanes, handle.id, "camera-full", [
+					{ camera },
+				]);
+				if (!moved) return handle;
+				return (await saveDocument(moved.doc, { history: true })) ? moved.handle : handle;
+			}
+			const id = handle.id;
+			const member = lanes.layout.find((r) => r.id === id);
+			const place = member?.slots[slotIndex];
+			if (!member || !place || place.camera === camera) return handle;
+			const slots = member.slots.map((slot, i) => {
+				if (i === slotIndex) return { ...slot, camera };
+				return slot.camera === camera ? { ...slot, camera: place.camera } : slot;
+			});
+			const result = isFullCameraLayout({ template: member.template, slots })
+				? layoutPillToFullCamera(document, lanes, id)
+				: {
+						doc: withCameraLanes(
+							document,
+							lanes,
+							lanes.full,
+							patchPillById(lanes.layout, id, { slots }),
+						),
+						handle,
+					};
+			if (!result) return handle;
+			return (await saveDocument(result.doc, { history: true })) ? result.handle : handle;
+		},
+		[document, saveDocument],
+	);
+
+	// Dragging a place in the preview: the same live/commit split as
+	// `updateAnnotationLive` / `commitAnnotationChange` — store-only writes while the
+	// pointer moves, one save (one undo step) on release.
+	const updateLayoutSlotRectLive = useCallback(
+		(id: string, slotIndex: number, rect: NormalizedRect) => {
+			const doc = useProjectStore.getState().document;
+			if (!doc) return;
+			const { x, y, width, height } = rect;
+			if (![x, y, width, height].every(Number.isFinite) || width <= 0 || height <= 0) return;
+			const lanes = cameraLanes(doc);
+			const member = lanes.layout.find((r) => r.id === id);
+			if (!member?.slots[slotIndex]) return;
+			if (layoutRectLiveRef.current !== doc) layoutRectRollbackRef.current = doc;
+			const slots = member.slots.map((slot, i) =>
+				i === slotIndex ? { camera: slot.camera, rect: { x, y, width, height } } : slot,
+			);
+			const next = withCameraLanes(
+				doc,
+				lanes,
+				lanes.full,
+				patchPillById(lanes.layout, id, { slots }),
+			);
+			setDocument(next, { history: false });
+			layoutRectLiveRef.current = next;
+		},
+		[setDocument],
+	);
+
+	const commitLayoutSlotRect = useCallback(async () => {
+		const doc = useProjectStore.getState().document;
+		if (!doc) return;
+		// See `commitAnnotationChange`: the pre-drag document counts only while the one on
+		// screen is still the one the live writes produced.
+		const rollback = layoutRectLiveRef.current === doc ? layoutRectRollbackRef.current : null;
+		layoutRectRollbackRef.current = null;
+		layoutRectLiveRef.current = null;
+		if (!(await saveDocument(doc, { history: true, historyBase: rollback })) && rollback) {
+			useProjectStore.setState((state) =>
+				state.document === doc ? { document: rollback, revision: state.revision + 1 } : {},
+			);
+		}
+	}, [saveDocument]);
+
+	// Every place of the section back to the template's own position: the rects are
+	// deleted, not set to a default, so a reset section is byte-identical to a fresh one.
+	const resetLayoutSlotRects = useCallback(
+		async (id: string) => {
+			if (!document) return;
+			const lanes = cameraLanes(document);
+			const member = lanes.layout.find((r) => r.id === id);
+			if (!member?.slots.some((slot) => slot.rect)) return;
+			const slots = member.slots.map((slot) => ({ camera: slot.camera }));
+			const layout = patchPillById(lanes.layout, id, { slots });
+			await saveDocument(withCameraLanes(document, lanes, lanes.full, layout), { history: true });
+		},
+		[document, saveDocument],
+	);
+
 	const removeRegion = useCallback(
 		async (kind: RegionKind, id: string) => {
 			if (!document) return;
@@ -1157,6 +1603,9 @@ export function useTimeline() {
 			const cameraFullscreenIds = new Set(
 				handles.filter((h) => h.kind === "cameraFullscreen").map((h) => h.id),
 			);
+			const cameraLayoutIds = new Set(
+				handles.filter((h) => h.kind === "cameraLayout").map((h) => h.id),
+			);
 			const legacy = (document.legacyEditor as Record<string, unknown>) ?? {};
 			const prevSpeed = dropPillsByIds(
 				(legacy.speedRegions as Array<{ id: string; startMs: number; endMs: number }>) ?? [],
@@ -1183,8 +1632,20 @@ export function useTimeline() {
 					),
 				},
 				legacyEditor:
-					speedIds.size > 0 || cameraFullscreenIds.size > 0
-						? { ...legacy, speedRegions: prevSpeed, cameraFullscreenRegions: prevCameraFullscreen }
+					speedIds.size > 0 || cameraFullscreenIds.size > 0 || cameraLayoutIds.size > 0
+						? {
+								...legacy,
+								speedRegions: prevSpeed,
+								cameraFullscreenRegions: prevCameraFullscreen,
+								...(cameraLayoutIds.size > 0
+									? {
+											cameraLayoutRegions: dropPillsByIds(
+												(legacy.cameraLayoutRegions as AnchoredCameraLayoutRegion[]) ?? [],
+												cameraLayoutIds,
+											),
+										}
+									: {}),
+							}
 						: document.legacyEditor,
 			};
 			if (!(await saveDocument(next, { history: true }))) return;
@@ -1502,6 +1963,16 @@ export function useTimeline() {
 				?.cameraFullscreenRegions as CameraFullscreenRegion[]) ?? [])
 		: [];
 
+	// Read through the normaliser: unlike Full Camera rows, a layout row carries nested
+	// data (template, slots, rects) that a hand-edited project can get wrong. Memoised so
+	// the list keeps its identity between renders of the same document.
+	const storedCameraLayouts = (document?.legacyEditor as Record<string, unknown> | null)
+		?.cameraLayoutRegions;
+	const cameraLayoutRegions = useMemo(
+		() => (hasDoc ? normalizeCameraLayoutRegions(storedCameraLayouts) : []),
+		[hasDoc, storedCameraLayouts],
+	);
+
 	// --- Timeline audio tracks (issue #350) -------------------------------------
 	// CLIP-ANCHORED like every region above: one user-visible track is one pill
 	// over one-or-more stored fragments, so these ops go through the shared pill
@@ -1678,6 +2149,14 @@ export function useTimeline() {
 		[updateAudioTrack],
 	);
 
+	const cameraSettings = useMemo(
+		() =>
+			normalizeCameraSettings(
+				(document?.legacyEditor as Record<string, unknown> | null)?.cameraSettings,
+			),
+		[document?.legacyEditor],
+	);
+
 	return {
 		zoomRegions: document?.zoomRanges ?? [],
 		trimRanges: document?.timeline.trimRanges ?? [],
@@ -1687,6 +2166,7 @@ export function useTimeline() {
 		annotationRegions: (document?.annotations ?? []) as unknown as AnnotationRegion[],
 		speedRegions,
 		cameraFullscreenRegions,
+		cameraLayoutRegions,
 		clips: document?.timeline.clips ?? [],
 		assets: document?.assets ?? [],
 		// The timeline marks where the user has ADDED words — text with no audio behind it.
@@ -1703,6 +2183,7 @@ export function useTimeline() {
 		addAnnotation,
 		addSpeed,
 		addCameraFullscreen,
+		addCameraLayout,
 		removeRegion,
 		removeRegions,
 		hasEditRegions,
@@ -1741,7 +2222,15 @@ export function useTimeline() {
 		updateSpeedValue,
 		updateCameraFullscreenOrientation,
 		updateCameraFullscreenDeskLabel,
+		setCameraSettings,
+		cameraSettings,
 		updateCameraFullscreenSpan,
+		updateCameraLayoutSpan,
+		setLayoutTemplate,
+		setLayoutSlotCamera,
+		updateLayoutSlotRectLive,
+		commitLayoutSlotRect,
+		resetLayoutSlotRects,
 		// T19 — drives the preview video during trim-edge resize.
 		setCurrentTime: useProjectStore((s) => s.setCurrentTime),
 	};
diff --git a/src/lib/ai-edition/timeline/calibrationGeometry.test.ts b/src/lib/ai-edition/timeline/calibrationGeometry.test.ts
new file mode 100644
index 000000000..0751af0e1
--- /dev/null
+++ b/src/lib/ai-edition/timeline/calibrationGeometry.test.ts
@@ -0,0 +1,154 @@
+import { describe, expect, it } from "vitest";
+import {
+	type Corners,
+	clampCrop,
+	isFullCrop,
+	isValidQuad,
+	loupeSourceRect,
+	nearestHandle,
+	previewSize,
+	renderRectified,
+	resizeCrop,
+} from "./calibrationGeometry";
+
+describe("calibrationGeometry", () => {
+	it("hit-tests the nearest handle within the radius", () => {
+		const points = [
+			{ x: 10, y: 10 },
+			{ x: 100, y: 10 },
+			{ x: 100, y: 100 },
+			{ x: 10, y: 100 },
+		];
+		expect(nearestHandle(points, { x: 95, y: 14 }, 12)).toBe(1);
+		expect(nearestHandle(points, { x: 14, y: 96 }, 12)).toBe(3);
+		expect(nearestHandle(points, { x: 55, y: 55 }, 12)).toBeNull();
+		// Two in reach: the closer one wins.
+		expect(
+			nearestHandle(
+				[
+					{ x: 0, y: 0 },
+					{ x: 6, y: 0 },
+				],
+				{ x: 4, y: 0 },
+				12,
+			),
+		).toBe(1);
+	});
+
+	it("the loupe rect stays inside the image", () => {
+		expect(loupeSourceRect({ x: 2, y: 3 }, 640, 360, 120, 4)).toEqual({
+			x: 0,
+			y: 0,
+			width: 30,
+			height: 30,
+		});
+		expect(loupeSourceRect({ x: 639, y: 359 }, 640, 360, 120, 4)).toEqual({
+			x: 610,
+			y: 330,
+			width: 30,
+			height: 30,
+		});
+		expect(loupeSourceRect({ x: 320, y: 180 }, 640, 360, 120, 4)).toEqual({
+			x: 305,
+			y: 165,
+			width: 30,
+			height: 30,
+		});
+		// An image smaller than the loupe's area is shown whole.
+		expect(loupeSourceRect({ x: 5, y: 5 }, 20, 10, 120, 4)).toEqual({
+			x: 0,
+			y: 0,
+			width: 20,
+			height: 10,
+		});
+	});
+
+	it("a crossed quad is invalid", () => {
+		const square: Corners = [
+			{ x: 0.1, y: 0.1 },
+			{ x: 0.9, y: 0.1 },
+			{ x: 0.9, y: 0.9 },
+			{ x: 0.1, y: 0.9 },
+		];
+		expect(isValidQuad(square)).toBe(true);
+		const crossed: Corners = [square[0], square[2], square[1], square[3]];
+		expect(isValidQuad(crossed)).toBe(false);
+		const collinear: Corners = [
+			{ x: 0.1, y: 0.1 },
+			{ x: 0.5, y: 0.1 },
+			{ x: 0.9, y: 0.1 },
+			{ x: 0.1, y: 0.9 },
+		];
+		expect(isValidQuad(collinear)).toBe(false);
+	});
+
+	it("the rectified preview maps the quad corners to the canvas corners", () => {
+		// A 100x100 grey image with a coloured 4x4 block at each corner of a skewed quad.
+		const size = 100;
+		const data = new Uint8ClampedArray(size * size * 4).fill(128);
+		const colours = [
+			[255, 0, 0],
+			[0, 255, 0],
+			[0, 0, 255],
+			[255, 255, 0],
+		];
+		const cornersPx = [
+			{ x: 20, y: 10 },
+			{ x: 80, y: 20 },
+			{ x: 90, y: 85 },
+			{ x: 10, y: 75 },
+		];
+		// Each block extends from the corner into the quad, so the corner pixel of the output
+		// (sampled half a pixel inside) lands in it.
+		const inward = [
+			[1, 1],
+			[-1, 1],
+			[-1, -1],
+			[1, -1],
+		];
+		cornersPx.forEach((c, k) => {
+			for (let dy = 0; dy < 4; dy++) {
+				for (let dx = 0; dx < 4; dx++) {
+					const x = c.x + inward[k][0] * dx - (inward[k][0] < 0 ? 1 : 0);
+					const y = c.y + inward[k][1] * dy - (inward[k][1] < 0 ? 1 : 0);
+					const o = (y * size + x) * 4;
+					data[o] = colours[k][0];
+					data[o + 1] = colours[k][1];
+					data[o + 2] = colours[k][2];
+				}
+			}
+		});
+		const corners = cornersPx.map((c) => ({ x: c.x / size, y: c.y / size })) as Corners;
+		const { width, height } = previewSize(1, 40);
+		const out = renderRectified(
+			{ width: size, height: size, data },
+			{ corners, aspect: 1 },
+			width,
+			height,
+		);
+		expect(out).not.toBeNull();
+		const at = (i: number, j: number) => {
+			const o = (j * width + i) * 4;
+			return [out?.[o], out?.[o + 1], out?.[o + 2]];
+		};
+		expect(at(0, 0)).toEqual(colours[0]);
+		expect(at(width - 1, 0)).toEqual(colours[1]);
+		expect(at(width - 1, height - 1)).toEqual(colours[2]);
+		expect(at(0, height - 1)).toEqual(colours[3]);
+		// The middle is the grey of the sheet.
+		expect(at(20, 20)).toEqual([128, 128, 128]);
+	});
+
+	it("keeps a crop inside the image and recognises the full frame", () => {
+		expect(clampCrop({ x: 0.9, y: -0.2, width: 0.5, height: 0.01 })).toEqual({
+			x: 0.5,
+			y: 0,
+			width: 0.5,
+			height: 0.04,
+		});
+		const r = resizeCrop({ x: 0.2, y: 0.2, width: 0.5, height: 0.5 }, { left: true }, -0.5, 0);
+		expect(r).toEqual({ x: 0, y: 0.2, width: 0.7, height: 0.5 });
+		expect(isFullCrop({ x: 0, y: 0, width: 1, height: 1 })).toBe(true);
+		expect(isFullCrop(r)).toBe(false);
+	});
+});
diff --git a/src/lib/ai-edition/timeline/calibrationGeometry.ts b/src/lib/ai-edition/timeline/calibrationGeometry.ts
new file mode 100644
index 000000000..74b475e14
--- /dev/null
+++ b/src/lib/ai-edition/timeline/calibrationGeometry.ts
@@ -0,0 +1,183 @@
+// Pure geometry behind the camera calibration dialog: which handle a pointer grabs, what the
+// loupe magnifies, whether a quad can be rectified, how a crop stays inside the frame, and the
+// rectified preview sampled through the homography. Corners and crops are normalized (0..1 of
+// the camera image); hit-tests and the loupe work in pixels of whatever space the caller uses.
+
+import type { CameraPerspective, CameraPoint, CropRegion } from "@/components/video-editor/types";
+import { homographyFromUnitSquare, perspectiveMatrix } from "@/lib/cameraPerspective";
+
+export type Corners = CameraPerspective["corners"];
+
+/** Corners a fresh calibration starts from: a rectangle inset from the image's edges. */
+export function insetCorners(inset = 0.15): Corners {
+	return [
+		{ x: inset, y: inset },
+		{ x: 1 - inset, y: inset },
+		{ x: 1 - inset, y: 1 - inset },
+		{ x: inset, y: 1 - inset },
+	];
+}
+
+/** Index of the point nearest to `p` within `radius`, or null when none is that close. */
+export function nearestHandle(
+	points: readonly CameraPoint[],
+	p: CameraPoint,
+	radius: number,
+): number | null {
+	let best: number | null = null;
+	let bestDist = radius;
+	points.forEach((q, i) => {
+		const d = Math.hypot(q.x - p.x, q.y - p.y);
+		if (d <= bestDist) {
+			best = i;
+			bestDist = d;
+		}
+	});
+	return best;
+}
+
+export interface PixelRect {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+
+/**
+ * The image area (pixels) a loupe of `size` px at `zoom`× shows around `center`, shifted so it
+ * never leaves the image; an image smaller than the area is shown whole.
+ */
+export function loupeSourceRect(
+	center: CameraPoint,
+	imageWidth: number,
+	imageHeight: number,
+	size: number,
+	zoom: number,
+): PixelRect {
+	const span = size / zoom;
+	const width = Math.min(span, imageWidth);
+	const height = Math.min(span, imageHeight);
+	const x = Math.min(Math.max(center.x - width / 2, 0), imageWidth - width);
+	const y = Math.min(Math.max(center.y - height / 2, 0), imageHeight - height);
+	return { x, y, width, height };
+}
+
+/** True when the four corners can be rectified: convex, not crossed, not collinear. */
+export function isValidQuad(corners: Corners): boolean {
+	return homographyFromUnitSquare(corners) !== null;
+}
+
+/** `p` kept inside the image (0..1 on both axes). */
+export function clampPoint(p: CameraPoint): CameraPoint {
+	return { x: Math.min(1, Math.max(0, p.x)), y: Math.min(1, Math.max(0, p.y)) };
+}
+
+/** Smallest crop side, as a fraction of the image. */
+export const MIN_CROP = 0.04;
+
+/** The crop moved and sized back inside the image, no side under `MIN_CROP`. */
+export function clampCrop(rect: CropRegion): CropRegion {
+	const width = Math.min(1, Math.max(MIN_CROP, rect.width));
+	const height = Math.min(1, Math.max(MIN_CROP, rect.height));
+	const x = Math.min(1 - width, Math.max(0, rect.x));
+	const y = Math.min(1 - height, Math.max(0, rect.y));
+	return { x, y, width, height };
+}
+
+export interface CropEdges {
+	left?: boolean;
+	right?: boolean;
+	top?: boolean;
+	bottom?: boolean;
+}
+
+/** `start` with its `edges` moved by (dx, dy), the opposite edges held, kept inside the image. */
+export function resizeCrop(
+	start: CropRegion,
+	edges: CropEdges,
+	dx: number,
+	dy: number,
+): CropRegion {
+	let left = start.x;
+	let right = start.x + start.width;
+	let top = start.y;
+	let bottom = start.y + start.height;
+	if (edges.left) left = Math.min(Math.max(0, left + dx), right - MIN_CROP);
+	if (edges.right) right = Math.max(Math.min(1, right + dx), left + MIN_CROP);
+	if (edges.top) top = Math.min(Math.max(0, top + dy), bottom - MIN_CROP);
+	if (edges.bottom) bottom = Math.max(Math.min(1, bottom + dy), top + MIN_CROP);
+	// An axis no edge moved keeps its exact numbers (no round trip through left/right).
+	const horizontal = edges.left || edges.right;
+	const vertical = edges.top || edges.bottom;
+	return {
+		x: horizontal ? left : start.x,
+		y: vertical ? top : start.y,
+		width: horizontal ? right - left : start.width,
+		height: vertical ? bottom - top : start.height,
+	};
+}
+
+/** `start` moved by (dx, dy) as a whole, its size kept, inside the image. */
+export function moveCrop(start: CropRegion, dx: number, dy: number): CropRegion {
+	return clampCrop({ ...start, x: start.x + dx, y: start.y + dy });
+}
+
+/** True when the crop covers the whole image (stored as "no crop"). */
+export function isFullCrop(rect: CropRegion): boolean {
+	const eps = 1e-6;
+	return rect.x <= eps && rect.y <= eps && rect.width >= 1 - eps && rect.height >= 1 - eps;
+}
+
+/** Size of the rectified preview: `longSide` on the longer side, `aspect` = width/height. */
+export function previewSize(aspect: number, longSide: number): { width: number; height: number } {
+	const a = Number.isFinite(aspect) && aspect > 0 ? aspect : 1;
+	return a >= 1
+		? { width: longSide, height: Math.max(1, Math.round(longSide / a)) }
+		: { width: Math.max(1, Math.round(longSide * a)), height: longSide };
+}
+
+/** Where (u, v) of the corrected picture lands in the camera image, normalized; null at infinity. */
+export function mapThrough(h: readonly number[], u: number, v: number): CameraPoint | null {
+	const w = h[6] * u + h[7] * v + h[8];
+	if (Math.abs(w) < 1e-12) return null;
+	return { x: (h[0] * u + h[1] * v + h[2]) / w, y: (h[3] * u + h[4] * v + h[5]) / w };
+}
+
+export interface RgbaImage {
+	width: number;
+	height: number;
+	data: Uint8ClampedArray;
+}
+
+/**
+ * The corrected picture, `width × height` RGBA, nearest-neighbour sampled from `image` through
+ * the perspective (margin included). Pixels that fall outside the camera image are black.
+ * Null when the quad cannot be rectified.
+ */
+export function renderRectified(
+	image: RgbaImage,
+	perspective: CameraPerspective,
+	width: number,
+	height: number,
+): Uint8ClampedArray<ArrayBuffer> | null {
+	const h = perspectiveMatrix(perspective);
+	if (!h) return null;
+	const out = new Uint8ClampedArray(width * height * 4);
+	for (let j = 0; j < height; j++) {
+		const v = (j + 0.5) / height;
+		for (let i = 0; i < width; i++) {
+			const o = (j * width + i) * 4;
+			out[o + 3] = 255;
+			const p = mapThrough(h, (i + 0.5) / width, v);
+			if (!p) continue;
+			const sx = Math.floor(p.x * image.width);
+			const sy = Math.floor(p.y * image.height);
+			if (sx < 0 || sy < 0 || sx >= image.width || sy >= image.height) continue;
+			const s = (sy * image.width + sx) * 4;
+			out[o] = image.data[s];
+			out[o + 1] = image.data[s + 1];
+			out[o + 2] = image.data[s + 2];
+		}
+	}
+	return out;
+}
diff --git a/src/lib/ai-edition/timeline/camera.test.ts b/src/lib/ai-edition/timeline/camera.test.ts
index 1f7fea91b..75e1edd6c 100644
--- a/src/lib/ai-edition/timeline/camera.test.ts
+++ b/src/lib/ai-edition/timeline/camera.test.ts
@@ -1,6 +1,11 @@
 import { describe, expect, it } from "vitest";
 import type { AxcutAsset, AxcutClip } from "../schema";
-import { assetCameraSource, hasAnyClipWithCamera, resolveActiveCameraTrack } from "./camera";
+import {
+	assetAdditionalCameraSources,
+	assetCameraSource,
+	hasAnyClipWithCamera,
+	resolveActiveCameraTrack,
+} from "./camera";
 
 const assetWithCamera: AxcutAsset = {
 	id: "asset_with_camera",
@@ -154,3 +159,31 @@ describe("assetCameraSource", () => {
 		expect(assetCameraSource(undefined)).toEqual({ path: "", offsetSec: 0 });
 	});
 });
+
+describe("assetAdditionalCameraSources", () => {
+	const track = (over: Partial<NonNullable<AxcutAsset["additionalCameraTracks"]>[number]>) => ({
+		sourcePath: "/w-2.mp4",
+		startMs: 0,
+		offsetMs: 0,
+		visible: true,
+		label: "",
+		...over,
+	});
+	it("is empty without extra tracks", () => {
+		expect(assetAdditionalCameraSources(assetWithCamera)).toEqual([]);
+	});
+	it("keeps one entry per track, with the offset in seconds", () => {
+		const asset = {
+			...assetWithCamera,
+			additionalCameraTracks: [track({ startMs: 500, offsetMs: -200 })],
+		};
+		expect(assetAdditionalCameraSources(asset)).toEqual([{ path: "/w-2.mp4", offsetSec: 0.3 }]);
+	});
+	it("a hidden track keeps its slot with an empty path", () => {
+		const asset = {
+			...assetWithCamera,
+			additionalCameraTracks: [track({ visible: false }), track({ sourcePath: "/w-3.mp4" })],
+		};
+		expect(assetAdditionalCameraSources(asset).map((c) => c.path)).toEqual(["", "/w-3.mp4"]);
+	});
+});
diff --git a/src/lib/ai-edition/timeline/camera.ts b/src/lib/ai-edition/timeline/camera.ts
index 4fc576952..e9e822eab 100644
--- a/src/lib/ai-edition/timeline/camera.ts
+++ b/src/lib/ai-edition/timeline/camera.ts
@@ -4,6 +4,7 @@
 // timeline, and whether the timeline has ANY camera at all — used to gate
 // camera-only preview chrome and settings controls.
 
+import type { CompositorClipCamera } from "@/native/contracts";
 import type { AxcutAsset, AxcutCameraTrack, AxcutClip } from "../schema";
 import { locateVirtualPosition } from "./virtual-preview";
 
@@ -50,3 +51,17 @@ export function assetCameraSource(asset: AxcutAsset | undefined): {
 	if (!cam?.visible || !cam.sourcePath) return { path: "", offsetSec: 0 };
 	return { path: cam.sourcePath, offsetSec: (cam.startMs + cam.offsetMs) / 1000 };
 }
+
+/**
+ * Cameras 2-4 of an asset, index k-1 = camera k. Same rule as `assetCameraSource`: a hidden
+ * track or one without a file is "no camera" (`path: ""`), but it keeps its slot so the
+ * indices stay aligned with `asset.additionalCameraTracks`.
+ */
+export function assetAdditionalCameraSources(
+	asset: AxcutAsset | undefined,
+): CompositorClipCamera[] {
+	return (asset?.additionalCameraTracks ?? []).map((cam) => ({
+		path: cam.visible && cam.sourcePath ? cam.sourcePath : "",
+		offsetSec: (cam.startMs + cam.offsetMs) / 1000,
+	}));
+}
diff --git a/src/lib/ai-edition/timeline/cameraList.test.ts b/src/lib/ai-edition/timeline/cameraList.test.ts
new file mode 100644
index 000000000..597bb3486
--- /dev/null
+++ b/src/lib/ai-edition/timeline/cameraList.test.ts
@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import type { AxcutAsset, AxcutClip, AxcutDocument } from "../schema";
+import { camerasForClipAt, camerasOfSection, projectCameras } from "./cameraList";
+
+const t = (key: string, vars?: Record<string, unknown>) =>
+	`${key}:${String(vars?.n ?? "")}${vars?.label ? `:${String(vars.label)}` : ""}`;
+
+const asset = (over: Partial<AxcutAsset> = {}): AxcutAsset =>
+	({
+		id: "a1",
+		kind: "video",
+		label: "a",
+		originalPath: "/screen.mp4",
+		cameraTrack: { sourcePath: "/c1.mp4", startMs: 0, offsetMs: 0, visible: true, width: 1920 },
+		additionalCameraTracks: [
+			{ sourcePath: "/c2.mp4", startMs: 0, offsetMs: 0, visible: true, label: "Desk" },
+			{ sourcePath: "/c3.mp4", startMs: 0, offsetMs: 0, visible: true, label: "" },
+		],
+		...over,
+	}) as AxcutAsset;
+
+const clip = (id: string, assetId: string, start: number, end: number): AxcutClip =>
+	({
+		id,
+		assetId,
+		sourceStartSec: 0,
+		sourceEndSec: end - start,
+		timelineStartSec: start,
+		timelineEndSec: end,
+		wordRefs: [],
+		origin: "system",
+		reason: "",
+	}) as AxcutClip;
+
+describe("projectCameras", () => {
+	it("labels camera 1 and falls back for empty labels", () => {
+		const cams = projectCameras(asset(), t);
+		expect(cams.map((c) => c.label)).toEqual([
+			"cameras.cameraN:1",
+			"cameras.cameraNamed:2:Desk",
+			"cameras.cameraN:3",
+		]);
+		expect(cams.map((c) => c.index)).toEqual([0, 1, 2]);
+		expect(cams[0].width).toBe(1920);
+	});
+
+	it("keeps two cameras of the same model apart by their ordinal", () => {
+		const twins = asset({
+			additionalCameraTracks: [
+				{ sourcePath: "/c2.mp4", startMs: 0, offsetMs: 0, visible: true, label: "C920" },
+				{ sourcePath: "/c3.mp4", startMs: 0, offsetMs: 0, visible: true, label: " C920 " },
+			],
+		});
+		expect(projectCameras(twins, t).map((c) => c.label)).toEqual([
+			"cameras.cameraN:1",
+			"cameras.cameraNamed:2:C920",
+			"cameras.cameraNamed:3:C920",
+		]);
+	});
+
+	it("a hidden track is unavailable", () => {
+		const hidden = asset({
+			additionalCameraTracks: [
+				{ sourcePath: "/c2.mp4", startMs: 0, offsetMs: 0, visible: false, label: "" },
+			],
+		});
+		const cams = projectCameras(hidden, t);
+		expect(cams.map((c) => c.available)).toEqual([true, false]);
+		expect(projectCameras(undefined, t)).toEqual([]);
+	});
+});
+
+describe("camerasForClipAt", () => {
+	it("cameras of the clip under the playhead", () => {
+		const single = asset({ id: "a2", additionalCameraTracks: [] });
+		const doc = {
+			assets: [asset(), single],
+			timeline: { clips: [clip("c1", "a1", 0, 5), clip("c2", "a2", 5, 10)] },
+		} as unknown as AxcutDocument;
+		expect(camerasForClipAt(doc, 2, t)).toHaveLength(3);
+		expect(camerasForClipAt(doc, 7, t)).toHaveLength(1);
+	});
+});
+
+describe("camerasOfSection", () => {
+	const single = asset({ id: "a2", additionalCameraTracks: [] });
+	const doc = {
+		assets: [asset(), single],
+		timeline: { clips: [clip("c1", "a1", 0, 5), clip("c2", "a2", 5, 10)] },
+	} as unknown as AxcutDocument;
+
+	it("reads the cameras of the anchored row's asset, not of the clip at its middle", () => {
+		// The span's middle (7 s) lies on the single-camera clip; the anchor names a1.
+		const row = { assetId: "a1", startMs: 4000, endMs: 10000 };
+		expect(camerasOfSection(doc, row, t)).toHaveLength(3);
+	});
+
+	it("falls back to the clip under the middle for a row without an anchor", () => {
+		expect(camerasOfSection(doc, { startMs: 4000, endMs: 10000 }, t)).toHaveLength(1);
+	});
+});
diff --git a/src/lib/ai-edition/timeline/cameraList.ts b/src/lib/ai-edition/timeline/cameraList.ts
new file mode 100644
index 000000000..bc84c7682
--- /dev/null
+++ b/src/lib/ai-edition/timeline/cameraList.ts
@@ -0,0 +1,77 @@
+// The cameras of a project, as the editor lists them: index 0 = camera 1 (`asset.cameraTrack`),
+// index k >= 1 = `asset.additionalCameraTracks[k - 1]`.
+
+import { MAX_CAMERAS } from "@/lib/cameraLayouts";
+import type { AxcutAsset, AxcutDocument } from "../schema";
+import { locateVirtualPosition } from "./virtual-preview";
+
+export interface ProjectCamera {
+	index: number;
+	label: string;
+	path: string;
+	available: boolean;
+	width?: number;
+	height?: number;
+}
+
+type Translate = (key: string, vars?: Record<string, string | number>) => string;
+
+/**
+ * Every camera is named by its ordinal ("Camera 2"); an extra camera with a device label adds
+ * it ("Camera 2 · Logitech C920"), so two cameras of the same model stay apart. Camera 1
+ * carries no label.
+ */
+export function projectCameras(asset: AxcutAsset | undefined, t: Translate): ProjectCamera[] {
+	if (!asset) return [];
+	const tracks = [asset.cameraTrack, ...(asset.additionalCameraTracks ?? [])].slice(0, MAX_CAMERAS);
+	const cameras: ProjectCamera[] = [];
+	tracks.forEach((track, index) => {
+		if (!track) return;
+		const own = index > 0 ? String((track as { label?: string }).label ?? "").trim() : "";
+		const camera: ProjectCamera = {
+			index,
+			label: own
+				? t("cameras.cameraNamed", { n: index + 1, label: own })
+				: t("cameras.cameraN", { n: index + 1 }),
+			path: track.sourcePath,
+			available: track.visible && track.sourcePath.length > 0,
+		};
+		if (track.width !== undefined) camera.width = track.width;
+		if (track.height !== undefined) camera.height = track.height;
+		cameras.push(camera);
+	});
+	return cameras;
+}
+
+/** The cameras of the asset whose clip is under the playhead (empty without a clip). */
+export function camerasForClipAt(
+	document: AxcutDocument,
+	timelineSec: number,
+	t: Translate,
+): ProjectCamera[] {
+	const position = locateVirtualPosition(document.timeline.clips, timelineSec);
+	if (!position) return [];
+	return projectCameras(
+		document.assets.find((a) => a.id === position.clip.assetId),
+		t,
+	);
+}
+
+/**
+ * The cameras of the asset a camera section is anchored to (its row's `assetId`). A row
+ * without an anchor (hand-written or legacy) falls back to the clip under its middle, so a
+ * section touching a cut is not taken for its neighbour's.
+ */
+export function camerasOfSection(
+	document: AxcutDocument,
+	row: { assetId?: string; startMs: number; endMs: number },
+	t: Translate,
+): ProjectCamera[] {
+	if (row.assetId !== undefined) {
+		return projectCameras(
+			document.assets.find((a) => a.id === row.assetId),
+			t,
+		);
+	}
+	return camerasForClipAt(document, (row.startMs + row.endMs) / 2000, t);
+}
diff --git a/src/lib/ai-edition/timeline/cameraSectionNotice.test.ts b/src/lib/ai-edition/timeline/cameraSectionNotice.test.ts
new file mode 100644
index 000000000..12f5d8735
--- /dev/null
+++ b/src/lib/ai-edition/timeline/cameraSectionNotice.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { cameraSectionNotice } from "./cameraSectionNotice";
+
+const t = (key: string) => key;
+
+describe("cameraSectionNotice", () => {
+	it("says nothing when the section was added", () => {
+		expect(cameraSectionNotice("added", t)).toBeNull();
+	});
+
+	it("names no section kind for an occupied spot", () => {
+		expect(cameraSectionNotice("occupied", t)).toEqual({
+			title: "errors.cannotPlaceCameraSection",
+			description: "errors.cameraSectionExistsAtLocation",
+		});
+	});
+
+	it("has a short notice for a missing or too small camera set", () => {
+		expect(cameraSectionNotice("no-camera", t)?.title).toBe("errors.noCamera");
+		expect(cameraSectionNotice("too-few-cameras", t)?.title).toBe("errors.tooFewCameras");
+	});
+});
diff --git a/src/lib/ai-edition/timeline/cameraSectionNotice.ts b/src/lib/ai-edition/timeline/cameraSectionNotice.ts
new file mode 100644
index 000000000..b9f629c3a
--- /dev/null
+++ b/src/lib/ai-edition/timeline/cameraSectionNotice.ts
@@ -0,0 +1,36 @@
+// What the user is told when adding a Full Camera or layout section does not happen.
+
+import { toast } from "sonner";
+
+type Translate = (key: string, vars?: Record<string, string | number>) => string;
+
+export type CameraSectionOutcome = "added" | "occupied" | "no-camera" | "too-few-cameras";
+
+/** The notice for an outcome, or `null` when the section was added. */
+export function cameraSectionNotice(
+	outcome: CameraSectionOutcome,
+	t: Translate,
+): { title: string; description?: string } | null {
+	switch (outcome) {
+		case "added":
+			return null;
+		// Neutral on purpose: what is in the way may be a Full Camera or a layout section, and
+		// the refused add or paste may be either kind too.
+		case "occupied":
+			return {
+				title: t("errors.cannotPlaceCameraSection"),
+				description: t("errors.cameraSectionExistsAtLocation"),
+			};
+		case "too-few-cameras":
+			return { title: t("errors.tooFewCameras") };
+		case "no-camera":
+			return { title: t("errors.noCamera") };
+	}
+}
+
+/** Show the notice for an outcome (nothing for "added"). `t` is the timeline namespace. */
+export function showCameraSectionOutcome(outcome: CameraSectionOutcome, t: Translate): void {
+	const notice = cameraSectionNotice(outcome, t);
+	if (!notice) return;
+	toast.error(notice.title, notice.description ? { description: notice.description } : undefined);
+}
diff --git a/src/lib/ai-edition/timeline/grabFrame.test.ts b/src/lib/ai-edition/timeline/grabFrame.test.ts
new file mode 100644
index 000000000..7f9d4d2cc
--- /dev/null
+++ b/src/lib/ai-edition/timeline/grabFrame.test.ts
@@ -0,0 +1,100 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { grabFrame, grabFrameDataUrl } from "./grabFrame";
+
+type FakeVideo = {
+	preload: string;
+	muted: boolean;
+	playsInline: boolean;
+	duration: number;
+	videoWidth: number;
+	videoHeight: number;
+	onloadedmetadata: (() => void) | null;
+	onseeked: (() => void) | null;
+	onerror: (() => void) | null;
+	seekedTo: number | null;
+	src: string;
+	currentTime: number;
+	removeAttribute: () => void;
+	load: () => void;
+};
+
+/** jsdom has no media: fake a video that "loads" on `src` and "seeks" on `currentTime`. */
+function installFakes(opts: { fail?: boolean } = {}) {
+	const draws: unknown[][] = [];
+	const imageData = { width: 48, height: 27, data: new Uint8ClampedArray(48 * 27 * 4) };
+	const canvas = {
+		width: 0,
+		height: 0,
+		getContext: () => ({
+			drawImage: (...args: unknown[]) => draws.push(args),
+			getImageData: () => imageData,
+		}),
+		toDataURL: () => "data:image/png;base64,AAAA",
+	};
+	let currentTime: number | null = null;
+	const video: FakeVideo = {
+		preload: "",
+		muted: false,
+		playsInline: false,
+		duration: 10,
+		videoWidth: 192,
+		videoHeight: 108,
+		onloadedmetadata: null,
+		onseeked: null,
+		onerror: null,
+		seekedTo: null,
+		removeAttribute: vi.fn(),
+		load: vi.fn(),
+		set src(_value: string) {
+			queueMicrotask(() => (opts.fail ? video.onerror?.() : video.onloadedmetadata?.()));
+		},
+		get src() {
+			return "";
+		},
+		set currentTime(value: number) {
+			currentTime = value;
+			video.seekedTo = value;
+			queueMicrotask(() => video.onseeked?.());
+		},
+		get currentTime() {
+			return currentTime ?? 0;
+		},
+	};
+	const real = document.createElement.bind(document);
+	vi.spyOn(document, "createElement").mockImplementation(((tag: string) => {
+		if (tag === "video") return video;
+		if (tag === "canvas") return canvas;
+		return real(tag);
+	}) as typeof document.createElement);
+	return { video, canvas, draws, imageData };
+}
+
+afterEach(() => vi.restoreAllMocks());
+
+describe("grabFrame", () => {
+	it("seeks to the time and draws the frame", async () => {
+		const { video, canvas, draws, imageData } = installFakes();
+		const data = await grabFrame("file:///cam.mp4", 3.5, 96);
+		expect(video.seekedTo).toBe(3.5);
+		expect(draws).toHaveLength(1);
+		// 192x108 scaled so the longer side is 96.
+		expect(canvas.width).toBe(96);
+		expect(canvas.height).toBe(54);
+		expect(data).toBe(imageData);
+	});
+
+	it("gives a data URL for the thumbnail", async () => {
+		installFakes();
+		await expect(grabFrameDataUrl("file:///cam.mp4", 1)).resolves.toBe(
+			"data:image/png;base64,AAAA",
+		);
+	});
+
+	it("rejects on error with a clear message", async () => {
+		installFakes({ fail: true });
+		await expect(grabFrame("file:///missing.mp4", 1)).rejects.toThrow(
+			"Could not load the video to grab a frame from file:///missing.mp4",
+		);
+	});
+});
diff --git a/src/lib/ai-edition/timeline/grabFrame.ts b/src/lib/ai-edition/timeline/grabFrame.ts
new file mode 100644
index 000000000..e1e54bb2d
--- /dev/null
+++ b/src/lib/ai-edition/timeline/grabFrame.ts
@@ -0,0 +1,97 @@
+// A still picture of a video at one time, for thumbnails and calibration. The renderer runs
+// without web security, so a local `file://` video drawn to a canvas is not tainted and its
+// pixels can be read (the webcam framing preview relies on the same).
+
+const DEFAULT_TIMEOUT_MS = 8000;
+
+/** Seeks an offscreen video to `timeSec` and draws that frame, scaled to `maxSide` if given. */
+function drawFrame(
+	src: string,
+	timeSec: number,
+	maxSide: number | undefined,
+	timeoutMs: number,
+): Promise<HTMLCanvasElement> {
+	return new Promise((resolve, reject) => {
+		if (typeof document === "undefined" || !src) {
+			reject(new Error("Cannot grab a video frame: no source"));
+			return;
+		}
+		const video = document.createElement("video");
+		video.preload = "auto";
+		video.muted = true;
+		video.playsInline = true;
+		let settled = false;
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const cleanup = () => {
+			if (timer !== undefined) clearTimeout(timer);
+			video.onloadedmetadata = null;
+			video.onseeked = null;
+			video.onerror = null;
+			try {
+				video.removeAttribute("src");
+				video.load();
+			} catch {
+				// ignore: the browser may refuse on a detached element
+			}
+		};
+		const fail = (message: string) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(new Error(message));
+		};
+		timer = setTimeout(() => fail(`Timed out grabbing a video frame from ${src}`), timeoutMs);
+		video.onerror = () => fail(`Could not load the video to grab a frame from ${src}`);
+		video.onloadedmetadata = () => {
+			const duration = Number.isFinite(video.duration) ? video.duration : timeSec;
+			// A hair before the end: seeking exactly to it can leave no frame to draw.
+			video.currentTime = Math.max(0, Math.min(timeSec, Math.max(0, duration - 0.001)));
+		};
+		video.onseeked = () => {
+			if (settled) return;
+			const { videoWidth, videoHeight } = video;
+			if (!(videoWidth > 0 && videoHeight > 0)) {
+				fail(`The video has no picture at ${timeSec}s: ${src}`);
+				return;
+			}
+			const scale = maxSide ? Math.min(1, maxSide / Math.max(videoWidth, videoHeight)) : 1;
+			const canvas = document.createElement("canvas");
+			canvas.width = Math.max(1, Math.round(videoWidth * scale));
+			canvas.height = Math.max(1, Math.round(videoHeight * scale));
+			const ctx = canvas.getContext("2d");
+			if (!ctx) {
+				fail("Cannot grab a video frame: no 2D canvas");
+				return;
+			}
+			ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+			settled = true;
+			cleanup();
+			resolve(canvas);
+		};
+		video.src = src;
+	});
+}
+
+/** The frame at `timeSec` as pixels; `maxSide` bounds the longer side (full size without it). */
+export async function grabFrame(
+	src: string,
+	timeSec: number,
+	maxSide?: number,
+	timeoutMs: number = DEFAULT_TIMEOUT_MS,
+): Promise<ImageData> {
+	const canvas = await drawFrame(src, timeSec, maxSide, timeoutMs);
+	const ctx = canvas.getContext("2d");
+	if (!ctx) throw new Error("Cannot read a video frame: no 2D canvas");
+	return ctx.getImageData(0, 0, canvas.width, canvas.height);
+}
+
+/** The frame at `timeSec` as a PNG data URL, 96 px on its longer side unless told otherwise. */
+export async function grabFrameDataUrl(
+	src: string,
+	timeSec: number,
+	maxSide = 96,
+	timeoutMs: number = DEFAULT_TIMEOUT_MS,
+): Promise<string> {
+	const canvas = await drawFrame(src, timeSec, maxSide, timeoutMs);
+	return canvas.toDataURL("image/png");
+}
diff --git a/src/lib/ai-edition/timeline/layoutMenu.test.ts b/src/lib/ai-edition/timeline/layoutMenu.test.ts
new file mode 100644
index 000000000..bf66f2609
--- /dev/null
+++ b/src/lib/ai-edition/timeline/layoutMenu.test.ts
@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import type { AxcutAsset, AxcutClip } from "../schema";
+import { camerasForLayoutMenu, defaultLayoutCameras, layoutTemplateBlock } from "./layoutMenu";
+
+describe("layoutTemplateBlock", () => {
+	it("blocks templates that need more cameras than the clip has", () => {
+		const ctx = { cameraCount: 1, blockPreset: false };
+		expect(layoutTemplateBlock("side-by-side", ctx)).toBe("needs-cameras");
+		expect(layoutTemplateBlock("camera-full-pip", ctx)).toBe("needs-cameras");
+		expect(layoutTemplateBlock("screen-pip", ctx)).toBeNull();
+		expect(layoutTemplateBlock("camera-full", ctx)).toBeNull();
+	});
+
+	it("blocks PiP templates under a block layout preset", () => {
+		const ctx = { cameraCount: 3, blockPreset: true };
+		expect(layoutTemplateBlock("screen-pip", ctx)).toBe("block-layout");
+		expect(layoutTemplateBlock("camera-full-pip", ctx)).toBe("block-layout");
+		expect(layoutTemplateBlock("side-by-side", ctx)).toBeNull();
+	});
+});
+
+describe("defaultLayoutCameras", () => {
+	it("takes the first N available cameras", () => {
+		expect(defaultLayoutCameras("screen-pip", [0, 1, 2])).toEqual([0]);
+		expect(defaultLayoutCameras("side-by-side", [0, 2, 3])).toEqual([0, 2]);
+		expect(defaultLayoutCameras("camera-full", [2, 3])).toEqual([2]);
+	});
+
+	it("puts the desk camera first for camera-full-pip", () => {
+		expect(defaultLayoutCameras("camera-full-pip", [0, 1])).toEqual([1, 0]);
+		expect(defaultLayoutCameras("camera-full-pip", [0, 2])).toEqual([0, 2]);
+	});
+});
+
+describe("camerasForLayoutMenu", () => {
+	const t = (key: string) => key;
+	const track = { sourcePath: "/c.mp4", startMs: 0, offsetMs: 0, visible: true, label: "" };
+	const assets = [
+		{ id: "screenOnly", kind: "video", additionalCameraTracks: [] },
+		{ id: "twoCams", kind: "video", cameraTrack: track, additionalCameraTracks: [track] },
+	] as unknown as AxcutAsset[];
+	const clip = (id: string, assetId: string, start: number, end: number): AxcutClip =>
+		({
+			id,
+			assetId,
+			sourceStartSec: 0,
+			sourceEndSec: end - start,
+			timelineStartSec: start,
+			timelineEndSec: end,
+		}) as AxcutClip;
+
+	it("uses the clip under the playhead", () => {
+		const clips = [clip("a", "screenOnly", 0, 5), clip("b", "twoCams", 5, 10)];
+		expect(camerasForLayoutMenu(clips, assets, 7, t)).toHaveLength(2);
+	});
+
+	it("keeps a camera-less clip under the playhead camera-less", () => {
+		const clips = [clip("a", "twoCams", 0, 5), clip("b", "screenOnly", 5, 10)];
+		expect(camerasForLayoutMenu(clips, assets, 8, t)).toEqual([]);
+	});
+
+	it("falls back to the nearest clip with cameras only when no clip is under the playhead", () => {
+		const clips = [clip("a", "twoCams", 0, 5), clip("b", "screenOnly", 5, 10)];
+		expect(camerasForLayoutMenu(clips, assets, 12, t)).toHaveLength(2);
+	});
+
+	it("is empty only when no clip has a camera", () => {
+		expect(camerasForLayoutMenu([clip("a", "screenOnly", 0, 5)], assets, 2, t)).toEqual([]);
+		expect(camerasForLayoutMenu([], assets, 0, t)).toEqual([]);
+	});
+});
diff --git a/src/lib/ai-edition/timeline/layoutMenu.ts b/src/lib/ai-edition/timeline/layoutMenu.ts
new file mode 100644
index 000000000..e348180ab
--- /dev/null
+++ b/src/lib/ai-edition/timeline/layoutMenu.ts
@@ -0,0 +1,86 @@
+// Rules behind the timeline's "Add layout" menu: which templates are offered, which are
+// disabled (and why), and which cameras a new section starts with.
+
+import type { CameraLayoutTemplate } from "@/components/video-editor/types";
+import { TEMPLATE_SLOTS } from "@/lib/cameraLayouts";
+import type { AxcutAsset, AxcutClip } from "../schema";
+import { type ProjectCamera, projectCameras } from "./cameraList";
+import { locateVirtualPosition } from "./virtual-preview";
+
+export const LAYOUT_TEMPLATES: readonly CameraLayoutTemplate[] = [
+	"screen-pip",
+	"camera-full",
+	"camera-full-pip",
+	"side-by-side",
+];
+
+/** Templates that place a picture-in-picture bubble over something. */
+const PIP_TEMPLATES: ReadonlySet<CameraLayoutTemplate> = new Set(["screen-pip", "camera-full-pip"]);
+
+export type LayoutTemplateBlock = "block-layout" | "needs-cameras";
+
+/**
+ * Why a template cannot be added right now, or `null` when it can. The block layout presets
+ * (dual-frame, vertical-stack) own the camera placement, so PiP templates are off there.
+ */
+export function layoutTemplateBlock(
+	template: CameraLayoutTemplate,
+	ctx: { cameraCount: number; blockPreset: boolean },
+): LayoutTemplateBlock | null {
+	if (ctx.blockPreset && PIP_TEMPLATES.has(template)) return "block-layout";
+	if (ctx.cameraCount < TEMPLATE_SLOTS[template].min) return "needs-cameras";
+	return null;
+}
+
+/**
+ * The cameras a new section of `template` starts with, from the available camera indexes of
+ * the clip under the playhead: the first `min` of them. `camera-full-pip` puts the desk
+ * camera (camera 2) first when there is one.
+ */
+export function defaultLayoutCameras(
+	template: CameraLayoutTemplate,
+	available: readonly number[],
+): number[] {
+	const { min } = TEMPLATE_SLOTS[template];
+	if (template === "camera-full-pip" && available.includes(1) && available.includes(0)) {
+		return [1, 0];
+	}
+	return available.slice(0, min);
+}
+
+/**
+ * The cameras the "Add layout" menu judges its templates by: those of the clip under the
+ * playhead, even when it has none (a section anchored on a screen-only clip would reference
+ * cameras its asset lacks). Only with no clip under the playhead (past every clip) does the
+ * menu fall back to the nearest clip that has cameras.
+ */
+export function camerasForLayoutMenu(
+	clips: AxcutClip[],
+	assets: AxcutAsset[],
+	timelineSec: number,
+	t: (key: string, vars?: Record<string, string | number>) => string,
+): ProjectCamera[] {
+	const availableOf = (clip: AxcutClip) =>
+		projectCameras(
+			assets.find((a) => a.id === clip.assetId),
+			t,
+		).filter((c) => c.available);
+	// `locateVirtualPosition` clamps to the nearest clip; "under" means the playhead is
+	// really inside it (its end included, for the playhead parked at the timeline's end).
+	const located = locateVirtualPosition(clips, timelineSec)?.clip;
+	const under =
+		located && timelineSec >= located.timelineStartSec && timelineSec <= located.timelineEndSec
+			? located
+			: null;
+	if (under) return availableOf(under);
+	const distance = (clip: AxcutClip) =>
+		Math.max(clip.timelineStartSec - timelineSec, timelineSec - clip.timelineEndSec, 0);
+	let best: { cameras: ProjectCamera[]; distance: number } | null = null;
+	for (const clip of clips) {
+		const cameras = availableOf(clip);
+		if (cameras.length === 0) continue;
+		const d = distance(clip);
+		if (!best || d < best.distance) best = { cameras, distance: d };
+	}
+	return best?.cameras ?? [];
+}
diff --git a/src/lib/ai-edition/timeline/layoutSlotDrag.test.ts b/src/lib/ai-edition/timeline/layoutSlotDrag.test.ts
new file mode 100644
index 000000000..183ee722b
--- /dev/null
+++ b/src/lib/ai-edition/timeline/layoutSlotDrag.test.ts
@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+import type { CameraLayoutRegion } from "@/components/video-editor/types";
+import type { CameraLayoutContext } from "@/lib/cameraLayoutTemplates";
+import {
+	inwardCorner,
+	MIN_SLOT_SHORT_SIDE_FRAC,
+	moveSlotRect,
+	pipPlacesOf,
+	resizeSlotRect,
+} from "./layoutSlotDrag";
+
+const FRAME = { width: 1920, height: 1080 };
+/** Pixel width / height of a rect in frame fractions. */
+const pixelAspect = (r: { width: number; height: number }) =>
+	(r.width * FRAME.width) / (r.height * FRAME.height);
+
+describe("moveSlotRect", () => {
+	it("moves inside the frame", () => {
+		const start = { x: 0.5, y: 0.5, width: 0.2, height: 0.2 };
+		expect(moveSlotRect(start, 0.1, -0.1)).toEqual({ x: 0.6, y: 0.4, width: 0.2, height: 0.2 });
+		// Past an edge, it stops flush against it.
+		expect(moveSlotRect(start, 0.9, 0.9)).toEqual({ x: 0.8, y: 0.8, width: 0.2, height: 0.2 });
+		expect(moveSlotRect(start, -0.9, -0.9)).toEqual({ x: 0, y: 0, width: 0.2, height: 0.2 });
+	});
+
+	it("brings a rect stored outside the frame back in", () => {
+		const moved = moveSlotRect({ x: 1.2, y: -0.3, width: 0.2, height: 0.2 }, 0, 0);
+		expect(moved).toEqual({ x: 0.8, y: 0, width: 0.2, height: 0.2 });
+	});
+});
+
+describe("resizeSlotRect", () => {
+	const start = { x: 0.5, y: 0.5, width: 0.2, height: (0.2 * 1920) / (16 / 9) / 1080 };
+
+	it("resize keeps the box aspect", () => {
+		const next = resizeSlotRect(start, "se", 0.1, 0.02, 16 / 9, FRAME);
+		expect(next.x).toBeCloseTo(0.5);
+		expect(next.y).toBeCloseTo(0.5);
+		expect(next.width).toBeGreaterThan(start.width);
+		expect(pixelAspect(next)).toBeCloseTo(16 / 9);
+	});
+
+	it("keeps the opposite corner fixed when dragging the top-left handle", () => {
+		const next = resizeSlotRect(start, "nw", -0.1, -0.1, 16 / 9, FRAME);
+		expect(next.x + next.width).toBeCloseTo(start.x + start.width);
+		expect(next.y + next.height).toBeCloseTo(start.y + start.height);
+		expect(pixelAspect(next)).toBeCloseTo(16 / 9);
+	});
+
+	it("a circle stays square", () => {
+		const square = { x: 0.6, y: 0.5, width: 0.1, height: (0.1 * 1920) / 1080 };
+		const next = resizeSlotRect(square, "nw", -0.05, -0.2, 1, FRAME);
+		expect(pixelAspect(next)).toBeCloseTo(1);
+		expect(next.width).toBeGreaterThan(square.width);
+	});
+
+	it("shrinks on a single-axis inward drag", () => {
+		const next = resizeSlotRect(start, "se", -0.05, 0, 16 / 9, FRAME);
+		expect(next.width).toBeCloseTo(start.width - 0.05);
+		expect(pixelAspect(next)).toBeCloseTo(16 / 9);
+		const vertical = resizeSlotRect(start, "se", 0, -0.02, 16 / 9, FRAME);
+		expect(vertical.height).toBeLessThan(start.height);
+	});
+
+	it("clamps to a minimum size", () => {
+		const next = resizeSlotRect(start, "se", -0.5, -0.5, 16 / 9, FRAME);
+		const shortSidePx = Math.min(next.width * FRAME.width, next.height * FRAME.height);
+		expect(shortSidePx).toBeCloseTo(MIN_SLOT_SHORT_SIDE_FRAC * FRAME.height);
+		expect(pixelAspect(next)).toBeCloseTo(16 / 9);
+	});
+
+	it("stops at the frame edge without losing the aspect", () => {
+		const next = resizeSlotRect(start, "se", 1, 1, 16 / 9, FRAME);
+		expect(next.x + next.width).toBeLessThanOrEqual(1 + 1e-9);
+		expect(next.y + next.height).toBeLessThanOrEqual(1 + 1e-9);
+		expect(pixelAspect(next)).toBeCloseTo(16 / 9);
+	});
+});
+
+describe("inwardCorner", () => {
+	it("points the handle towards the middle of the frame", () => {
+		expect(inwardCorner({ x: 0.7, y: 0.7, width: 0.2, height: 0.2 })).toBe("nw");
+		expect(inwardCorner({ x: 0.1, y: 0.7, width: 0.2, height: 0.2 })).toBe("ne");
+		expect(inwardCorner({ x: 0.7, y: 0.1, width: 0.2, height: 0.2 })).toBe("sw");
+		expect(inwardCorner({ x: 0.1, y: 0.1, width: 0.2, height: 0.2 })).toBe("se");
+	});
+});
+
+describe("pipPlacesOf", () => {
+	const ctx: CameraLayoutContext = {
+		frame: FRAME,
+		cameraAspect: () => 16 / 9,
+		pipShape: "rounded",
+		pipRadiusFrac: 0.1,
+	};
+
+	it("lists only the PiP places, with their slot index", () => {
+		const region: CameraLayoutRegion = {
+			id: "l1",
+			startMs: 0,
+			endMs: 1000,
+			template: "camera-full-pip",
+			slots: [{ camera: 1 }, { camera: 0 }, { camera: 2 }],
+		};
+		const places = pipPlacesOf(region, ctx);
+		expect(places.map((p) => [p.slotIndex, p.camera])).toEqual([
+			[1, 0],
+			[2, 2],
+		]);
+		expect(places[0].aspect).toBeCloseTo(16 / 9);
+	});
+
+	it("locks circle and square places to a square", () => {
+		const region: CameraLayoutRegion = {
+			id: "l1",
+			startMs: 0,
+			endMs: 1000,
+			template: "screen-pip",
+			slots: [{ camera: 0 }],
+		};
+		expect(pipPlacesOf(region, { ...ctx, pipShape: "circle" })[0].aspect).toBe(1);
+	});
+
+	it("has no place for a frame-filling template", () => {
+		const region: CameraLayoutRegion = {
+			id: "l1",
+			startMs: 0,
+			endMs: 1000,
+			template: "side-by-side",
+			slots: [{ camera: 0 }, { camera: 1 }],
+		};
+		expect(pipPlacesOf(region, ctx)).toEqual([]);
+	});
+});
diff --git a/src/lib/ai-edition/timeline/layoutSlotDrag.ts b/src/lib/ai-edition/timeline/layoutSlotDrag.ts
new file mode 100644
index 000000000..9627130a8
--- /dev/null
+++ b/src/lib/ai-edition/timeline/layoutSlotDrag.ts
@@ -0,0 +1,123 @@
+// Geometry behind dragging a layout section's camera places in the preview: which places can
+// be moved (the PiPs), and how a move or a corner resize keeps a place inside the frame, above
+// a minimum size and at its box's proportions. Everything is in output-frame fractions; the
+// frame's pixel size only enters where proportions are measured in pixels.
+
+import type { CameraLayoutRegion, NormalizedRect } from "@/components/video-editor/types";
+import {
+	type CameraLayoutContext,
+	type ResolvedCameraLayer,
+	resolveCameraLayout,
+	slotFillsFrame,
+} from "@/lib/cameraLayoutTemplates";
+
+/** The smallest a place may get: its short side, as a fraction of the frame's short side. */
+export const MIN_SLOT_SHORT_SIDE_FRAC = 0.05;
+
+export type SlotCorner = "nw" | "ne" | "sw" | "se";
+
+type FrameSize = { width: number; height: number };
+
+/** A PiP place of a section, as the preview offers it for dragging. */
+export interface PipPlace {
+	/** Index into `region.slots` (not into the resolved layers, which list frame-fillers first). */
+	slotIndex: number;
+	camera: number;
+	rect: NormalizedRect;
+	shape: ResolvedCameraLayer["shape"];
+	/** Pixel width / height the place keeps while resized: 1 for a circle or square. */
+	aspect: number;
+}
+
+/** The section's PiP places, where the compositor draws them. Frame-filling places have none. */
+export function pipPlacesOf(region: CameraLayoutRegion, ctx: CameraLayoutContext): PipPlace[] {
+	const pipSlots = region.slots
+		.map((_, index) => index)
+		.filter((index) => !slotFillsFrame(region.template, index));
+	// The resolver lists PiPs after the frame-fillers, each in slot order.
+	const pipLayers = resolveCameraLayout(region, ctx).filter((layer) => !layer.fillsFrame);
+	return pipLayers.map((layer, k) => {
+		const squareBox = layer.shape === "circle" || layer.shape === "square";
+		const cameraAspect = ctx.cameraAspect(layer.camera);
+		const safeAspect = Number.isFinite(cameraAspect) && cameraAspect > 0 ? cameraAspect : 16 / 9;
+		return {
+			slotIndex: pipSlots[k] ?? k,
+			camera: layer.camera,
+			rect: layer.rect,
+			shape: layer.shape,
+			aspect: squareBox ? 1 : safeAspect,
+		};
+	});
+}
+
+function clamp(value: number, min: number, max: number): number {
+	return Math.min(Math.max(value, min), max);
+}
+
+/** The rect no larger than the frame and inside it (a stored rect may reach past it). */
+function insideFrame(rect: NormalizedRect): NormalizedRect {
+	const width = Math.min(rect.width, 1);
+	const height = Math.min(rect.height, 1);
+	return {
+		x: clamp(rect.x, 0, 1 - width),
+		y: clamp(rect.y, 0, 1 - height),
+		width,
+		height,
+	};
+}
+
+/** `start` moved by (dx, dy) frame fractions, stopping flush against the frame's edges. */
+export function moveSlotRect(start: NormalizedRect, dx: number, dy: number): NormalizedRect {
+	const fitted = insideFrame(start);
+	return insideFrame({ ...fitted, x: fitted.x + dx, y: fitted.y + dy });
+}
+
+/**
+ * `start` resized by dragging its `corner` by (dx, dy) frame fractions. The opposite corner
+ * stays put; the size follows whichever axis the pointer pulled further, at `aspect` (pixel
+ * width / height), between the minimum size and the frame's edges.
+ */
+export function resizeSlotRect(
+	start: NormalizedRect,
+	corner: SlotCorner,
+	dx: number,
+	dy: number,
+	aspect: number,
+	frame: FrameSize,
+): NormalizedRect {
+	const rect = insideFrame(start);
+	const signX = corner === "ne" || corner === "se" ? 1 : -1;
+	const signY = corner === "sw" || corner === "se" ? 1 : -1;
+	const fixedX = signX > 0 ? rect.x : rect.x + rect.width;
+	const fixedY = signY > 0 ? rect.y : rect.y + rect.height;
+	// Widths in pixels: the one the pointer asks for along each axis.
+	const fromX = (rect.width + signX * dx) * frame.width;
+	const fromY = (rect.height + signY * dy) * frame.height * aspect;
+	const minWidth =
+		MIN_SLOT_SHORT_SIDE_FRAC * Math.min(frame.width, frame.height) * Math.max(1, aspect);
+	const roomX = signX > 0 ? 1 - fixedX : fixedX;
+	const roomY = signY > 0 ? 1 - fixedY : fixedY;
+	const maxWidth = Math.min(roomX * frame.width, roomY * frame.height * aspect);
+	// The frame wins over the minimum: a place never leaves it.
+	// Follow the axis with the larger change, so a single-axis inward drag shrinks the box too.
+	const changeX = Math.abs(fromX - rect.width * frame.width);
+	const changeY = Math.abs(fromY - rect.height * frame.height * aspect);
+	const asked = changeX >= changeY ? fromX : fromY;
+	const widthPx = Math.min(Math.max(asked, minWidth), maxWidth);
+	const width = widthPx / frame.width;
+	const height = widthPx / aspect / frame.height;
+	return {
+		x: signX > 0 ? fixedX : fixedX - width,
+		y: signY > 0 ? fixedY : fixedY - height,
+		width,
+		height,
+	};
+}
+
+/** The corner of `rect` that faces the middle of the frame: where its resize handle sits. */
+export function inwardCorner(rect: NormalizedRect): SlotCorner {
+	const right = rect.x + rect.width / 2 < 0.5;
+	const bottom = rect.y + rect.height / 2 < 0.5;
+	if (bottom) return right ? "se" : "sw";
+	return right ? "ne" : "nw";
+}
diff --git a/src/lib/arucoMarkers.test.ts b/src/lib/arucoMarkers.test.ts
new file mode 100644
index 000000000..a3193927a
--- /dev/null
+++ b/src/lib/arucoMarkers.test.ts
@@ -0,0 +1,189 @@
+import { describe, expect, it } from "vitest";
+import { detectCornerMarkers, markerBits, type RgbaImage } from "./arucoMarkers";
+
+// A plain rasterizer: a white sheet with markers drawn from the dictionary bits, seen through a
+// homography (sheet units → image pixels). Every image pixel is mapped back onto the sheet and
+// sampled 4x4 times, so edges are anti-aliased like a camera's.
+
+type Mat3 = number[];
+interface Pt {
+	x: number;
+	y: number;
+}
+
+/** The homography taking the unit square's corners (0,0),(1,0),(1,1),(0,1) to `q`. */
+function squareToQuad(q: [Pt, Pt, Pt, Pt]): Mat3 {
+	const [p0, p1, p2, p3] = q;
+	const dx1 = p1.x - p2.x;
+	const dx2 = p3.x - p2.x;
+	const dx3 = p0.x - p1.x + p2.x - p3.x;
+	const dy1 = p1.y - p2.y;
+	const dy2 = p3.y - p2.y;
+	const dy3 = p0.y - p1.y + p2.y - p3.y;
+	const den = dx1 * dy2 - dx2 * dy1;
+	const g = (dx3 * dy2 - dx2 * dy3) / den;
+	const h = (dx1 * dy3 - dx3 * dy1) / den;
+	return [
+		p1.x - p0.x + g * p1.x,
+		p3.x - p0.x + h * p3.x,
+		p0.x,
+		p1.y - p0.y + g * p1.y,
+		p3.y - p0.y + h * p3.y,
+		p0.y,
+		g,
+		h,
+		1,
+	];
+}
+
+function apply(m: Mat3, p: Pt): Pt {
+	const w = m[6] * p.x + m[7] * p.y + m[8];
+	return { x: (m[0] * p.x + m[1] * p.y + m[2]) / w, y: (m[3] * p.x + m[4] * p.y + m[5]) / w };
+}
+
+function invert(m: Mat3): Mat3 {
+	const [a, b, c, d, e, f, g, h, i] = m;
+	const A = e * i - f * h;
+	const B = -(d * i - f * g);
+	const C = d * h - e * g;
+	const det = a * A + b * B + c * C;
+	return [
+		A / det,
+		-(b * i - c * h) / det,
+		(b * f - c * e) / det,
+		B / det,
+		(a * i - c * g) / det,
+		-(a * f - c * d) / det,
+		C / det,
+		-(a * h - b * g) / det,
+		(a * e - b * d) / det,
+	];
+}
+
+const SHEET_W = 200;
+const SHEET_H = 150;
+const MARKER = 36; // sheet units per marker side (6 cells of 6)
+const INSET = 10;
+
+/** Each marker's top-left on the sheet: one per sheet corner. */
+const MARKER_ORIGINS: Record<number, Pt> = {
+	0: { x: INSET, y: INSET },
+	1: { x: SHEET_W - INSET - MARKER, y: INSET },
+	2: { x: SHEET_W - INSET - MARKER, y: SHEET_H - INSET - MARKER },
+	3: { x: INSET, y: SHEET_H - INSET - MARKER },
+};
+
+/** The marker corner facing the sheet's middle, in sheet units. */
+const INNER_ON_SHEET: Pt[] = [
+	{ x: INSET + MARKER, y: INSET + MARKER },
+	{ x: SHEET_W - INSET - MARKER, y: INSET + MARKER },
+	{ x: SHEET_W - INSET - MARKER, y: SHEET_H - INSET - MARKER },
+	{ x: INSET + MARKER, y: SHEET_H - INSET - MARKER },
+];
+
+/** 0 (black) or 1 (white) at a sheet point. */
+function sheetValue(p: Pt, ids: number[], bits: Map<number, boolean[][]>): number {
+	for (const id of ids) {
+		const o = MARKER_ORIGINS[id];
+		const u = (p.x - o.x) / (MARKER / 6);
+		const v = (p.y - o.y) / (MARKER / 6);
+		if (u < 0 || v < 0 || u >= 6 || v >= 6) continue;
+		const cx = Math.floor(u);
+		const cy = Math.floor(v);
+		if (cx === 0 || cy === 0 || cx === 5 || cy === 5) return 0; // black border
+		return bits.get(id)?.[cy - 1][cx - 1] ? 1 : 0;
+	}
+	return 1;
+}
+
+/** The sheet (with markers `ids`) photographed so its corners land on `sheetCorners` (px). */
+function photograph(
+	width: number,
+	height: number,
+	sheetCorners: [Pt, Pt, Pt, Pt],
+	ids: number[],
+): { image: RgbaImage; toImage: (p: Pt) => Pt } {
+	const unitToImage = squareToQuad(sheetCorners);
+	const toImage = (p: Pt) => apply(unitToImage, { x: p.x / SHEET_W, y: p.y / SHEET_H });
+	const imageToUnit = invert(unitToImage);
+	const bits = new Map(ids.map((id) => [id, markerBits(id)]));
+	const data = new Uint8ClampedArray(width * height * 4);
+	const SS = 4;
+	for (let y = 0; y < height; y++) {
+		for (let x = 0; x < width; x++) {
+			let sum = 0;
+			let inside = 0;
+			for (let sy = 0; sy < SS; sy++) {
+				for (let sx = 0; sx < SS; sx++) {
+					const u = apply(imageToUnit, { x: x + (sx + 0.5) / SS, y: y + (sy + 0.5) / SS });
+					if (u.x < 0 || u.y < 0 || u.x > 1 || u.y > 1) continue;
+					inside++;
+					sum += sheetValue({ x: u.x * SHEET_W, y: u.y * SHEET_H }, ids, bits);
+				}
+			}
+			// The desk around the sheet is a mid grey; paper white is 235, ink 20.
+			const n = SS * SS;
+			const value = ((n - inside) * 110 + sum * 235 + (inside - sum) * 20) / n;
+			const i = (y * width + x) * 4;
+			data[i] = value;
+			data[i + 1] = value;
+			data[i + 2] = value;
+			data[i + 3] = 255;
+		}
+	}
+	return { image: { width, height, data }, toImage };
+}
+
+const W = 640;
+const H = 480;
+/** A slight perspective: the far edge narrower, a little tilt. */
+const TILTED: [Pt, Pt, Pt, Pt] = [
+	{ x: 120, y: 70 },
+	{ x: 530, y: 85 },
+	{ x: 590, y: 420 },
+	{ x: 60, y: 400 },
+];
+
+function expectNear(actual: Pt, expected: Pt, tolPx: number) {
+	expect(Math.abs(actual.x * W - expected.x)).toBeLessThanOrEqual(tolPx);
+	expect(Math.abs(actual.y * H - expected.y)).toBeLessThanOrEqual(tolPx);
+}
+
+describe("detectCornerMarkers", () => {
+	it("detects four markers and orders the inner corners", () => {
+		const { image, toImage } = photograph(W, H, TILTED, [0, 1, 2, 3]);
+		const corners = detectCornerMarkers(image);
+		expect(corners).not.toBeNull();
+		corners?.forEach((c, i) => {
+			expectNear(c, toImage(INNER_ON_SHEET[i]), 1.5);
+		});
+	});
+
+	it("fewer than four markers leaves the corners unchanged", () => {
+		const { image } = photograph(W, H, TILTED, [0, 1, 3]);
+		expect(detectCornerMarkers(image)).toBeNull();
+	});
+
+	it("a rotated sheet still maps id 0 to top-left", () => {
+		// The sheet turned a quarter clockwise: its top-left corner now lies top-right.
+		const rotated: [Pt, Pt, Pt, Pt] = [
+			{ x: 520, y: 40 },
+			{ x: 540, y: 440 },
+			{ x: 230, y: 430 },
+			{ x: 220, y: 60 },
+		];
+		const { image, toImage } = photograph(W, H, rotated, [0, 1, 2, 3]);
+		const corners = detectCornerMarkers(image);
+		expect(corners).not.toBeNull();
+		corners?.forEach((c, i) => {
+			expectNear(c, toImage(INNER_ON_SHEET[i]), 1.5);
+		});
+		// Marker 0 sits on the right of the picture now, and is still returned first.
+		expect(corners?.[0].x).toBeGreaterThan(0.5);
+	});
+
+	it("an empty picture finds nothing", () => {
+		const { image } = photograph(W, H, TILTED, []);
+		expect(detectCornerMarkers(image)).toBeNull();
+	});
+});
diff --git a/src/lib/arucoMarkers.ts b/src/lib/arucoMarkers.ts
new file mode 100644
index 000000000..914685764
--- /dev/null
+++ b/src/lib/arucoMarkers.ts
@@ -0,0 +1,138 @@
+// Finds the four corner markers of the printed marker sheet in a camera still, so the
+// calibration dialog can place its handles without dragging. Detection is js-aruco2 (MIT,
+// pure JS); the markers are OpenCV's DICT_4X4_50, i.e. the first 50 codes of js-aruco2's
+// ARUCO_4X4_1000. The printed sheet (`markerSheet.ts`) draws from the same dictionary.
+
+import aruco, { type ArucoDetector, type ArucoDictionary, type ArucoMarker } from "js-aruco2";
+// Registers ARUCO_4X4_1000 in `AR.DICTIONARIES` (side effect).
+import "js-aruco2/src/dictionaries/aruco_4x4_1000.js";
+import type { CameraPoint } from "@/components/video-editor/types";
+
+/** The four inner corners, normalized 0..1: TL (id 0), TR (1), BR (2), BL (3). */
+export type MarkerCorners = [CameraPoint, CameraPoint, CameraPoint, CameraPoint];
+
+/** The detector's view of an RGBA picture; `ImageData` fits. */
+export interface RgbaImage {
+	width: number;
+	height: number;
+	data: ArrayLike<number>;
+}
+
+const { AR } = aruco;
+
+/** DICT_4X4_50: fewer codes than the 1000 set, so far fewer chance matches on a desk. */
+const DICTIONARY_NAME = "OPENSCREEN_4X4_50";
+const DICTIONARY_SIZE = 50;
+/** Accepts a code at most one bit off (js-aruco2 tests `distance < maxHammingDistance`). */
+const MAX_HAMMING_DISTANCE = 2;
+
+/** The marker IDs of the sheet, in handle order: top-left, top-right, bottom-right, bottom-left. */
+export const CORNER_MARKER_IDS = [0, 1, 2, 3] as const;
+
+let dictionary: ArucoDictionary | null = null;
+let detector: ArucoDetector | null = null;
+
+function registerDictionary() {
+	if (AR.DICTIONARIES[DICTIONARY_NAME]) return;
+	const full = AR.DICTIONARIES.ARUCO_4X4_1000;
+	AR.DICTIONARIES[DICTIONARY_NAME] = {
+		nBits: full.nBits,
+		tau: null,
+		codeList: full.codeList.slice(0, DICTIONARY_SIZE),
+	};
+}
+
+/** The marker dictionary, built once. */
+export function markerDictionary(): ArucoDictionary {
+	if (!dictionary) {
+		registerDictionary();
+		dictionary = new AR.Dictionary(DICTIONARY_NAME);
+	}
+	return dictionary;
+}
+
+/**
+ * The data cells of marker `id` (without its black border), row-major; true = white.
+ * A 4x4 marker gives four rows of four.
+ */
+export function markerBits(id: number): boolean[][] {
+	const dict = markerDictionary();
+	const code = dict.codeList[id];
+	if (code === undefined) throw new RangeError(`No marker ${id} in the dictionary`);
+	const side = Math.round(Math.sqrt(dict.nBits));
+	const rows: boolean[][] = [];
+	for (let y = 0; y < side; y++) {
+		rows.push(Array.from({ length: side }, (_, x) => code[y * side + x] === "1"));
+	}
+	return rows;
+}
+
+function getDetector(): ArucoDetector {
+	if (!detector) {
+		registerDictionary();
+		detector = new AR.Detector({
+			dictionaryName: DICTIONARY_NAME,
+			maxHammingDistance: MAX_HAMMING_DISTANCE,
+		});
+	}
+	return detector;
+}
+
+/** Of several detections of one ID, the cleanest read, then the largest. */
+function better(a: ArucoMarker, b: ArucoMarker): ArucoMarker {
+	if (a.hammingDistance !== b.hammingDistance) {
+		return a.hammingDistance < b.hammingDistance ? a : b;
+	}
+	return perimeter(a) >= perimeter(b) ? a : b;
+}
+
+function perimeter(m: ArucoMarker): number {
+	let sum = 0;
+	for (let i = 0; i < m.corners.length; i++) {
+		const p = m.corners[i];
+		const q = m.corners[(i + 1) % m.corners.length];
+		sum += Math.hypot(q.x - p.x, q.y - p.y);
+	}
+	return sum;
+}
+
+/**
+ * Finds markers 0–3 (ARUCO 4x4) and returns the four inner corners as TL (id 0), TR (1),
+ * BR (2), BL (3); null unless all four are found. The inner corner of a marker is its corner
+ * closest to the centroid of the four markers, so the sheet may lie at any rotation.
+ */
+export function detectCornerMarkers(image: RgbaImage): MarkerCorners | null {
+	if (image.width <= 0 || image.height <= 0) return null;
+	const found = new Map<number, ArucoMarker>();
+	for (const marker of getDetector().detectImage(image.width, image.height, image.data)) {
+		if (!(CORNER_MARKER_IDS as readonly number[]).includes(marker.id)) continue;
+		if (marker.corners.length !== 4) continue;
+		const previous = found.get(marker.id);
+		found.set(marker.id, previous ? better(previous, marker) : marker);
+	}
+	const markers = CORNER_MARKER_IDS.map((id) => found.get(id));
+	if (markers.some((m) => m === undefined)) return null;
+	const all = markers as ArucoMarker[];
+
+	const centers = all.map((m) => ({
+		x: m.corners.reduce((s, c) => s + c.x, 0) / 4,
+		y: m.corners.reduce((s, c) => s + c.y, 0) / 4,
+	}));
+	const centroid = {
+		x: centers.reduce((s, c) => s + c.x, 0) / 4,
+		y: centers.reduce((s, c) => s + c.y, 0) / 4,
+	};
+	const inner = all.map((m) => {
+		let best = m.corners[0];
+		for (const c of m.corners) {
+			if (
+				Math.hypot(c.x - centroid.x, c.y - centroid.y) <
+				Math.hypot(best.x - centroid.x, best.y - centroid.y)
+			) {
+				best = c;
+			}
+		}
+		return { x: best.x / image.width, y: best.y / image.height };
+	});
+	return [inner[0], inner[1], inner[2], inner[3]];
+}
diff --git a/src/lib/cameraLayoutTemplates.test.ts b/src/lib/cameraLayoutTemplates.test.ts
new file mode 100644
index 000000000..842074bd4
--- /dev/null
+++ b/src/lib/cameraLayoutTemplates.test.ts
@@ -0,0 +1,136 @@
+import { describe, expect, it } from "vitest";
+import {
+	PIP_GAP_FRAC,
+	PIP_MARGIN_FRAC,
+	PIP_WIDTH_FRAC,
+	resolveCameraLayout,
+} from "./cameraLayoutTemplates";
+
+const ctx = {
+	frame: { width: 1920, height: 1080 },
+	cameraAspect: () => 16 / 9,
+	pipShape: "rounded" as const,
+	pipRadiusFrac: 0.12,
+};
+const region = (template: never, cameras: number[], rects: Record<number, unknown> = {}) =>
+	({
+		id: "r",
+		startMs: 0,
+		endMs: 5000,
+		template,
+		slots: cameras.map((camera, i) => ({ camera, ...(rects[i] ? { rect: rects[i] } : {}) })),
+	}) as never;
+
+describe("resolveCameraLayout", () => {
+	it("camera-full fills the frame", () => {
+		expect(resolveCameraLayout(region("camera-full" as never, [2]), ctx)).toEqual([
+			{
+				camera: 2,
+				rect: { x: 0, y: 0, width: 1, height: 1 },
+				radiusFrac: 0,
+				shape: "rectangle",
+				fillsFrame: true,
+			},
+		]);
+	});
+	it("side-by-side splits the frame in halves", () => {
+		const layers = resolveCameraLayout(region("side-by-side" as never, [0, 1]), ctx);
+		expect(layers.map((l) => l.rect)).toEqual([
+			{ x: 0, y: 0, width: 0.5, height: 1 },
+			{ x: 0.5, y: 0, width: 0.5, height: 1 },
+		]);
+	});
+	it("screen-pip stacks pips from the bottom-right corner leftwards", () => {
+		const [a, b] = resolveCameraLayout(region("screen-pip" as never, [0, 1]), ctx);
+		expect(a.rect.x + a.rect.width).toBeCloseTo(1 - PIP_MARGIN_FRAC, 9);
+		expect(a.rect.width).toBeCloseTo(PIP_WIDTH_FRAC, 9);
+		expect(a.rect.height).toBeCloseTo(PIP_WIDTH_FRAC, 9); // 16:9 camera in a 16:9 frame
+		expect(b.rect.x + b.rect.width).toBeLessThan(a.rect.x);
+		expect([a.fillsFrame, b.fillsFrame]).toEqual([false, false]);
+	});
+	it("the first pip takes the project's default pip rect, the next stacks left of it", () => {
+		// A 16:9 camera's default PiP, 0.3 wide, in the top-left corner of a 16:9 frame.
+		const defaultPipRect = { x: 0.05, y: 0.06, width: 0.3, height: 0.3 };
+		const [a, b] = resolveCameraLayout(region("screen-pip" as never, [0, 1]), {
+			...ctx,
+			defaultPipRect,
+		});
+		for (const key of ["x", "y", "width", "height"] as const) {
+			expect(a.rect[key]).toBeCloseTo(defaultPipRect[key], 9);
+		}
+		expect(b.rect.width).toBeCloseTo(0.3, 9);
+		expect(b.rect.x + b.rect.width).toBeCloseTo(a.rect.x - PIP_GAP_FRAC, 9);
+		expect(b.rect.y + b.rect.height).toBeCloseTo(a.rect.y + a.rect.height, 9);
+		// A portrait camera keeps the width and bottom edge, with its own height.
+		const [p] = resolveCameraLayout(region("screen-pip" as never, [1]), {
+			...ctx,
+			cameraAspect: () => 9 / 16,
+			defaultPipRect,
+		});
+		expect(p.rect.width).toBeCloseTo(0.3, 9);
+		expect(p.rect.y + p.rect.height).toBeCloseTo(0.36, 9);
+		expect((p.rect.width * 1920) / (p.rect.height * 1080)).toBeCloseTo(9 / 16, 6);
+	});
+	it("without a usable default pip rect the corner constants stay", () => {
+		const plain = resolveCameraLayout(region("screen-pip" as never, [0, 1]), ctx);
+		for (const defaultPipRect of [null, { x: 0, y: 0, width: 0, height: 0.2 }]) {
+			expect(
+				resolveCameraLayout(region("screen-pip" as never, [0, 1]), { ...ctx, defaultPipRect }),
+			).toEqual(plain);
+		}
+	});
+	it("camera-full-pip draws the full camera first, then the pip", () => {
+		const layers = resolveCameraLayout(region("camera-full-pip" as never, [1, 0]), ctx);
+		expect(layers.map((l) => [l.camera, l.fillsFrame])).toEqual([
+			[1, true],
+			[0, false],
+		]);
+	});
+	it("a user rect overrides the template position", () => {
+		const rect = { x: 0.1, y: 0.1, width: 0.3, height: 0.3 };
+		const [layer] = resolveCameraLayout(region("screen-pip" as never, [1], { 0: rect }), ctx);
+		expect(layer.rect).toEqual(rect);
+	});
+	it("a portrait camera gets a taller pip box", () => {
+		const [layer] = resolveCameraLayout(region("screen-pip" as never, [1]), {
+			...ctx,
+			cameraAspect: () => 9 / 16,
+		});
+		expect(layer.rect.height).toBeGreaterThan(layer.rect.width);
+	});
+	it("circle and square pips use a square box and the project's shape", () => {
+		const [layer] = resolveCameraLayout(region("screen-pip" as never, [1]), {
+			...ctx,
+			pipShape: "circle",
+			cameraAspect: () => 4 / 3,
+		});
+		expect(layer.shape).toBe("circle");
+		expect(layer.rect.width * 1920).toBeCloseTo(layer.rect.height * 1080, 9);
+	});
+	it("a user rect on a full layer keeps its fillsFrame flag", () => {
+		const rect = { x: 0, y: 0, width: 0.6, height: 1 };
+		const [layer] = resolveCameraLayout(region("camera-full" as never, [1], { 0: rect }), ctx);
+		expect(layer).toMatchObject({ rect, fillsFrame: true, shape: "rectangle" });
+	});
+	it("returns copies of the template rects", () => {
+		const [layer] = resolveCameraLayout(region("camera-full" as never, [1]), ctx);
+		layer.rect.width = 0.1;
+		const [again] = resolveCameraLayout(region("camera-full" as never, [1]), ctx);
+		expect(again.rect.width).toBe(1);
+		const [left] = resolveCameraLayout(region("side-by-side" as never, [0, 1]), ctx);
+		left.rect.width = 0.1;
+		expect(resolveCameraLayout(region("side-by-side" as never, [0, 1]), ctx)[0].rect.width).toBe(
+			0.5,
+		);
+	});
+	it("treats a non-finite or non-positive camera aspect as 16/9", () => {
+		const [ref] = resolveCameraLayout(region("screen-pip" as never, [1]), ctx);
+		for (const bad of [Number.NaN, 0, -2, Number.POSITIVE_INFINITY]) {
+			const [layer] = resolveCameraLayout(region("screen-pip" as never, [1]), {
+				...ctx,
+				cameraAspect: () => bad,
+			});
+			expect(layer.rect).toEqual(ref.rect);
+		}
+	});
+});
diff --git a/src/lib/cameraLayoutTemplates.ts b/src/lib/cameraLayoutTemplates.ts
new file mode 100644
index 000000000..3491b043b
--- /dev/null
+++ b/src/lib/cameraLayoutTemplates.ts
@@ -0,0 +1,105 @@
+import type { CameraLayoutRegion, NormalizedRect } from "@/components/video-editor/types";
+
+export interface ResolvedCameraLayer {
+	camera: number;
+	/** Output-frame fractions. */
+	rect: NormalizedRect;
+	/** Corner radius as a fraction of min(rect width, height) in pixels. */
+	radiusFrac: number;
+	/** Same vocabulary as `SceneLayout.webcamShape` (what the compositor's `webcam_shape_code` reads). */
+	shape: "rectangle" | "rounded" | "circle" | "square";
+	/** Covers the screen: drawn without a shadow. */
+	fillsFrame: boolean;
+}
+
+export interface CameraLayoutContext {
+	/** Output pixels. */
+	frame: { width: number; height: number };
+	/** Width/height of that camera's box (the perspective aspect when one is set). */
+	cameraAspect: (camera: number) => number;
+	/** The project's webcam shape. */
+	pipShape: ResolvedCameraLayer["shape"];
+	/** The project's webcam radius fraction. */
+	pipRadiusFrac: number;
+	/**
+	 * The clip's default camera-1 PiP (output-frame fractions), where the project places it.
+	 * The first PiP takes its width and its right/bottom edges; further PiPs stack leftwards
+	 * at the same width. Without it the PiPs sit in the bottom-right corner at `PIP_WIDTH_FRAC`.
+	 */
+	defaultPipRect?: NormalizedRect | null;
+}
+
+export const PIP_WIDTH_FRAC = 0.22;
+export const PIP_MARGIN_FRAC = 0.025;
+export const PIP_GAP_FRAC = 0.02;
+
+const FULL_RECT: NormalizedRect = { x: 0, y: 0, width: 1, height: 1 };
+const LEFT_HALF: NormalizedRect = { x: 0, y: 0, width: 0.5, height: 1 };
+const RIGHT_HALF: NormalizedRect = { x: 0.5, y: 0, width: 0.5, height: 1 };
+
+function fullLayer(camera: number, rect: NormalizedRect): ResolvedCameraLayer {
+	return { camera, rect, radiusFrac: 0, shape: "rectangle", fillsFrame: true };
+}
+
+function usableRect(rect: NormalizedRect | null | undefined): NormalizedRect | null {
+	if (!rect) return null;
+	const values = [rect.x, rect.y, rect.width, rect.height];
+	return values.every(Number.isFinite) && rect.width > 0 && rect.height > 0 ? rect : null;
+}
+
+function pipLayer(camera: number, index: number, ctx: CameraLayoutContext): ResolvedCameraLayer {
+	const { width, height } = ctx.frame;
+	const anchor = usableRect(ctx.defaultPipRect);
+	const w = anchor ? anchor.width : PIP_WIDTH_FRAC;
+	const squareBox = ctx.pipShape === "circle" || ctx.pipShape === "square";
+	const cameraAspect = ctx.cameraAspect(camera);
+	const safeAspect = Number.isFinite(cameraAspect) && cameraAspect > 0 ? cameraAspect : 16 / 9;
+	const aspect = squareBox ? 1 : safeAspect;
+	const h = (w * width) / aspect / height;
+	const firstRight = anchor ? anchor.x + anchor.width : 1 - PIP_MARGIN_FRAC;
+	const right = firstRight - index * (w + PIP_GAP_FRAC);
+	const bottom = anchor ? anchor.y + anchor.height : 1 - (PIP_MARGIN_FRAC * width) / height;
+	return {
+		camera,
+		rect: { x: right - w, y: bottom - h, width: w, height: h },
+		radiusFrac: ctx.pipRadiusFrac,
+		shape: ctx.pipShape,
+		fillsFrame: false,
+	};
+}
+
+/** Whether a template's place `index` covers the frame (or half of it) rather than being a PiP. */
+export function slotFillsFrame(template: CameraLayoutRegion["template"], index: number): boolean {
+	return (
+		template === "camera-full" ||
+		template === "side-by-side" ||
+		(template === "camera-full-pip" && index === 0)
+	);
+}
+
+/**
+ * Turns a layout region into positioned camera layers in draw order: frame-filling layers
+ * first, then the PiPs, each in slot order. A slot's own `rect` overrides the template's
+ * position but keeps its flags.
+ */
+export function resolveCameraLayout(
+	region: CameraLayoutRegion,
+	ctx: CameraLayoutContext,
+): ResolvedCameraLayer[] {
+	const full: ResolvedCameraLayer[] = [];
+	const pips: ResolvedCameraLayer[] = [];
+	region.slots.forEach((slot, i) => {
+		let layer: ResolvedCameraLayer;
+		if (region.template === "side-by-side") {
+			layer = fullLayer(slot.camera, { ...(i === 0 ? LEFT_HALF : RIGHT_HALF) });
+		} else if (slotFillsFrame(region.template, i)) {
+			layer = fullLayer(slot.camera, { ...FULL_RECT });
+		} else {
+			const pipIndex = region.template === "camera-full-pip" ? i - 1 : i;
+			layer = pipLayer(slot.camera, pipIndex, ctx);
+		}
+		if (slot.rect) layer = { ...layer, rect: { ...slot.rect } };
+		(layer.fillsFrame ? full : pips).push(layer);
+	});
+	return [...full, ...pips];
+}
diff --git a/src/lib/cameraLayouts.test.ts b/src/lib/cameraLayouts.test.ts
new file mode 100644
index 000000000..8e13ae17e
--- /dev/null
+++ b/src/lib/cameraLayouts.test.ts
@@ -0,0 +1,299 @@
+import { describe, expect, it } from "vitest";
+import {
+	cameraSectionsOverlapping,
+	fullCameraRowsOfLayoutList,
+	isFullCameraLayout,
+	MAX_CAMERAS,
+	normalizeCameraLayoutRegions,
+	normalizeCameraSettings,
+	patchCameraSettings,
+} from "./cameraLayouts";
+
+const base = { id: "a", startMs: 0, endMs: 1000 };
+const persp = {
+	corners: [
+		{ x: 0.1, y: 0.1 },
+		{ x: 0.9, y: 0.1 },
+		{ x: 0.9, y: 0.9 },
+		{ x: 0.1, y: 0.9 },
+	],
+	aspect: 1.5,
+};
+
+describe("normalizeCameraLayoutRegions", () => {
+	it("round-trips a valid region", () => {
+		const region = {
+			...base,
+			template: "side-by-side",
+			slots: [{ camera: 0 }, { camera: 1, rect: { x: 0.5, y: 0, width: 0.5, height: 1 } }],
+		};
+		expect(normalizeCameraLayoutRegions([region])).toEqual([region]);
+	});
+	it("returns [] for non-arrays and drops non-objects", () => {
+		expect(normalizeCameraLayoutRegions("x")).toEqual([]);
+		expect(normalizeCameraLayoutRegions([null, 3, "s"])).toEqual([]);
+	});
+	it("drops an unknown template", () => {
+		expect(
+			normalizeCameraLayoutRegions([{ ...base, template: "grid", slots: [{ camera: 0 }] }]),
+		).toEqual([]);
+	});
+	it("removes a duplicate camera from slots (first wins)", () => {
+		const out = normalizeCameraLayoutRegions([
+			{ ...base, template: "screen-pip", slots: [{ camera: 1 }, { camera: 1 }, { camera: 2 }] },
+		]);
+		expect(out[0].slots).toEqual([{ camera: 1 }, { camera: 2 }]);
+	});
+	it("drops out-of-range cameras and clamps to the template maximum", () => {
+		const out = normalizeCameraLayoutRegions([
+			{
+				...base,
+				template: "side-by-side",
+				slots: [{ camera: MAX_CAMERAS }, { camera: 0 }, { camera: 1 }, { camera: 2 }],
+			},
+		]);
+		expect(out[0].slots).toEqual([{ camera: 0 }, { camera: 1 }]);
+	});
+	it("drops camera-full-pip with a single slot", () => {
+		expect(
+			normalizeCameraLayoutRegions([
+				{ ...base, template: "camera-full-pip", slots: [{ camera: 0 }] },
+			]),
+		).toEqual([]);
+	});
+	it("drops a region whose end is not after its start", () => {
+		expect(
+			normalizeCameraLayoutRegions([
+				{ ...base, endMs: 0, template: "camera-full", slots: [{ camera: 1 }] },
+			]),
+		).toEqual([]);
+	});
+	it("sorts by start and drops the later of two overlapping regions", () => {
+		const mk = (id: string, startMs: number, endMs: number) => ({
+			id,
+			startMs,
+			endMs,
+			template: "camera-full",
+			slots: [{ camera: 1 }],
+		});
+		const out = normalizeCameraLayoutRegions([
+			mk("c", 1000, 2000),
+			mk("b", 500, 1500),
+			mk("a", 0, 1000),
+		]);
+		expect(out.map((r) => r.id)).toEqual(["a", "c"]);
+	});
+	it("removes a rect containing NaN but keeps the slot", () => {
+		const out = normalizeCameraLayoutRegions([
+			{
+				...base,
+				template: "screen-pip",
+				slots: [{ camera: 1, rect: { x: Number.NaN, y: 0, width: 0.2, height: 0.2 } }],
+			},
+		]);
+		expect(out[0].slots).toEqual([{ camera: 1 }]);
+	});
+	it("removes a rect with non-positive size or outside the allowed range", () => {
+		const out = normalizeCameraLayoutRegions([
+			{
+				...base,
+				template: "screen-pip",
+				slots: [
+					{ camera: 1, rect: { x: 0, y: 0, width: 0, height: 0.2 } },
+					{ camera: 2, rect: { x: 2, y: 0, width: 0.2, height: 0.2 } },
+				],
+			},
+		]);
+		expect(out[0].slots).toEqual([{ camera: 1 }, { camera: 2 }]);
+	});
+	it("strips desk fields from a non camera-full template", () => {
+		const out = normalizeCameraLayoutRegions([
+			{
+				...base,
+				template: "screen-pip",
+				slots: [{ camera: 1 }],
+				rotation: 180,
+				mirror: "on",
+				deskLabel: false,
+			},
+		]);
+		expect(out[0]).toEqual({ ...base, template: "screen-pip", slots: [{ camera: 1 }] });
+	});
+	it("strips desk fields from a camera-full region of another camera", () => {
+		const out = normalizeCameraLayoutRegions([
+			{
+				...base,
+				template: "camera-full",
+				slots: [{ camera: 2 }],
+				rotation: 180,
+				mirror: "on",
+				deskLabel: false,
+			},
+		]);
+		expect(out[0]).toEqual({ ...base, template: "camera-full", slots: [{ camera: 2 }] });
+	});
+	it("keeps the clip anchor fields", () => {
+		const anchor = { clipId: "clip-a", assetId: "asset-a", sourceStartSec: 4, sourceEndSec: 5 };
+		const out = normalizeCameraLayoutRegions([
+			{ ...base, ...anchor, template: "screen-pip", slots: [{ camera: 1 }] },
+			{
+				...base,
+				id: "b",
+				startMs: 2000,
+				endMs: 3000,
+				clipId: 7,
+				sourceStartSec: Number.NaN,
+				template: "screen-pip",
+				slots: [{ camera: 1 }],
+			},
+		]);
+		expect(out[0]).toEqual({ ...base, ...anchor, template: "screen-pip", slots: [{ camera: 1 }] });
+		expect(out[1]).toEqual({
+			id: "b",
+			startMs: 2000,
+			endMs: 3000,
+			template: "screen-pip",
+			slots: [{ camera: 1 }],
+		});
+	});
+	it("drops a camera-full row for camera 1 (it belongs to full camera)", () => {
+		const out = normalizeCameraLayoutRegions([
+			{ ...base, template: "camera-full", slots: [{ camera: 0 }] },
+			{ ...base, id: "b", template: "camera-full", slots: [{ camera: 1 }] },
+		]);
+		expect(out.map((r) => r.id)).toEqual(["b"]);
+	});
+});
+
+describe("isFullCameraLayout", () => {
+	it("is true only for camera-full with camera 1", () => {
+		expect(isFullCameraLayout({ template: "camera-full", slots: [{ camera: 0 }] })).toBe(true);
+		expect(isFullCameraLayout({ template: "camera-full", slots: [{ camera: 1 }] })).toBe(false);
+		expect(isFullCameraLayout({ template: "screen-pip", slots: [{ camera: 0 }] })).toBe(false);
+	});
+
+	it("is false for a camera-full row that names more than one camera", () => {
+		expect(
+			isFullCameraLayout({ template: "camera-full", slots: [{ camera: 0 }, { camera: 1 }] }),
+		).toBe(false);
+	});
+});
+
+describe("fullCameraRowsOfLayoutList", () => {
+	it("keeps normalized desk fields on a camera-1 camera-full row", () => {
+		const out = fullCameraRowsOfLayoutList([
+			{
+				...base,
+				template: "camera-full",
+				slots: [{ camera: 0 }],
+				rotation: 180,
+				mirror: "on",
+				deskLabel: false,
+			},
+			{ ...base, id: "b", template: "screen-pip", slots: [{ camera: 0 }] },
+		]);
+		expect(out).toEqual([
+			{
+				...base,
+				template: "camera-full",
+				slots: [{ camera: 0 }],
+				rotation: 180,
+				mirror: "on",
+				deskLabel: false,
+			},
+		]);
+	});
+});
+
+describe("normalizeCameraSettings", () => {
+	it("returns [] for non-arrays", () => {
+		expect(normalizeCameraSettings(undefined)).toEqual([]);
+	});
+	it("clamps to four entries, maps junk to null and keeps valid settings", () => {
+		const out = normalizeCameraSettings([
+			null,
+			{ rotation: 180, perspective: persp },
+			"junk",
+			{ mirror: true },
+			{ rotation: 180 },
+		]);
+		expect(out).toEqual([null, { rotation: 180, perspective: persp }, null, { mirror: true }]);
+	});
+	it("removes a perspective with aspect 0", () => {
+		expect(
+			normalizeCameraSettings([{ rotation: 180, perspective: { ...persp, aspect: 0 } }]),
+		).toEqual([{ rotation: 180 }]);
+	});
+	it("removes a perspective with a corner outside the range or non-finite", () => {
+		const bad = { ...persp, corners: [{ x: 3, y: 0 }, ...persp.corners.slice(1)] };
+		const nan = { ...persp, corners: [{ x: Number.NaN, y: 0 }, ...persp.corners.slice(1)] };
+		expect(normalizeCameraSettings([{ perspective: bad }, { perspective: nan }])).toEqual([{}, {}]);
+	});
+	it("clamps the perspective margin to [0, 0.2]", () => {
+		const out = normalizeCameraSettings([
+			{ perspective: { ...persp, margin: 0.9 } },
+			{ perspective: { ...persp, margin: -1 } },
+		]);
+		expect(out[0]?.perspective?.margin).toBe(0.2);
+		expect(out[1]?.perspective?.margin).toBe(0);
+	});
+	it("keeps a finite crop and drops an invalid one", () => {
+		const crop = { x: 0.1, y: 0.1, width: 0.5, height: 0.5 };
+		expect(normalizeCameraSettings([{ crop }, { crop: { ...crop, width: 0 } }])).toEqual([
+			{ crop },
+			{},
+		]);
+	});
+});
+
+describe("patchCameraSettings", () => {
+	it("an out-of-range index leaves the list alone", () => {
+		expect(patchCameraSettings([null, { mirror: true }], MAX_CAMERAS, { mirror: true })).toEqual([
+			null,
+			{ mirror: true },
+		]);
+		expect(patchCameraSettings(undefined, -1, { mirror: true })).toBeUndefined();
+		expect(patchCameraSettings(undefined, 1.5, { mirror: true })).toBeUndefined();
+	});
+
+	it("trims trailing nulls but keeps a middle hole", () => {
+		const raw = [null, { mirror: true }, null, { rotation: 180 }];
+		expect(patchCameraSettings(raw, 3, null)).toEqual([null, { mirror: true }]);
+		expect(patchCameraSettings(raw, 1, null)).toEqual([null, null, null, { rotation: 180 }]);
+	});
+
+	it("undefined clears a key", () => {
+		const raw = [null, { mirror: true, rotation: 180 }];
+		expect(patchCameraSettings(raw, 1, { mirror: undefined })).toEqual([null, { rotation: 180 }]);
+	});
+
+	it("drops defaults", () => {
+		expect(patchCameraSettings(undefined, 1, { rotation: 0, mirror: false })).toBeUndefined();
+		expect(patchCameraSettings([null, { mirror: true }], 1, { mirror: false })).toBeUndefined();
+	});
+
+	it("null resets a middle camera", () => {
+		const raw = [null, { mirror: true }, { rotation: 180 }];
+		expect(patchCameraSettings(raw, 1, null)).toEqual([null, null, { rotation: 180 }]);
+	});
+});
+
+describe("cameraSectionsOverlapping", () => {
+	const rows = [
+		{ id: "a", startMs: 1000, endMs: 2000 },
+		{ id: "b", startMs: 3000, endMs: 4000 },
+	];
+
+	it("returns every row the span overlaps", () => {
+		expect(cameraSectionsOverlapping(rows, 1500, 3500).map((r) => r.id)).toEqual(["a", "b"]);
+	});
+
+	it("does not count touching as overlap", () => {
+		expect(cameraSectionsOverlapping(rows, 2000, 3000)).toEqual([]);
+		expect(cameraSectionsOverlapping(rows, 0, 1000)).toEqual([]);
+	});
+
+	it("finds a row the span lies inside", () => {
+		expect(cameraSectionsOverlapping(rows, 3200, 3300).map((r) => r.id)).toEqual(["b"]);
+	});
+});
diff --git a/src/lib/cameraLayouts.ts b/src/lib/cameraLayouts.ts
new file mode 100644
index 000000000..da7d49c52
--- /dev/null
+++ b/src/lib/cameraLayouts.ts
@@ -0,0 +1,256 @@
+import type {
+	CameraLayoutRegion,
+	CameraLayoutSlot,
+	CameraLayoutTemplate,
+	CameraPerspective,
+	CameraSettings,
+	CropRegion,
+	NormalizedRect,
+} from "@/components/video-editor/types";
+import { normalizeCameraMirror, normalizeCameraRotation } from "./cameraOrientation";
+
+export const MAX_CAMERAS = 4;
+
+export const TEMPLATE_SLOTS: Record<CameraLayoutTemplate, { min: number; max: number }> = {
+	"screen-pip": { min: 1, max: 3 },
+	"camera-full": { min: 1, max: 1 },
+	"camera-full-pip": { min: 2, max: 3 },
+	"side-by-side": { min: 2, max: 2 },
+};
+
+const RECT_MIN = -0.5;
+const RECT_MAX = 1.5;
+const MAX_MARGIN = 0.2;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function inRange(value: unknown, min: number, max: number): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value >= min && value <= max;
+}
+
+const TEMPLATES: ReadonlySet<string> = new Set(Object.keys(TEMPLATE_SLOTS));
+
+function isTemplate(value: unknown): value is CameraLayoutTemplate {
+	return typeof value === "string" && TEMPLATES.has(value);
+}
+
+function normalizeRect(raw: unknown): NormalizedRect | undefined {
+	if (!isRecord(raw)) return undefined;
+	const { x, y, width, height } = raw;
+	if (
+		!inRange(x, RECT_MIN, RECT_MAX) ||
+		!inRange(y, RECT_MIN, RECT_MAX) ||
+		!inRange(width, RECT_MIN, RECT_MAX) ||
+		!inRange(height, RECT_MIN, RECT_MAX) ||
+		width <= 0 ||
+		height <= 0
+	) {
+		return undefined;
+	}
+	return { x, y, width, height };
+}
+
+function normalizeSlots(raw: unknown, template: CameraLayoutTemplate): CameraLayoutSlot[] {
+	if (!Array.isArray(raw)) return [];
+	const seen = new Set<number>();
+	const slots: CameraLayoutSlot[] = [];
+	for (const entry of raw) {
+		if (!isRecord(entry)) continue;
+		const camera = entry.camera;
+		if (!Number.isInteger(camera) || (camera as number) < 0 || (camera as number) >= MAX_CAMERAS) {
+			continue;
+		}
+		if (seen.has(camera as number)) continue;
+		seen.add(camera as number);
+		const rect = normalizeRect(entry.rect);
+		slots.push(rect ? { camera: camera as number, rect } : { camera: camera as number });
+	}
+	return slots.slice(0, TEMPLATE_SLOTS[template].max);
+}
+
+/** A stored layout section: like a Full Camera region it is clip-anchored, so the anchor
+ *  fields are the source of truth and `startMs`/`endMs` a derived cache. */
+export type AnchoredCameraLayoutRegion = CameraLayoutRegion & {
+	clipId?: string;
+	assetId?: string;
+	sourceStartSec?: number;
+	sourceEndSec?: number;
+};
+
+/** A `camera-full` section of camera 1: that is a Full Camera region, never a layout row. */
+export function isFullCameraLayout(
+	region: Pick<CameraLayoutRegion, "template" | "slots">,
+): boolean {
+	return (
+		region.template === "camera-full" && region.slots.length === 1 && region.slots[0]?.camera === 0
+	);
+}
+
+function copyAnchor(raw: Record<string, unknown>, region: AnchoredCameraLayoutRegion): void {
+	if (typeof raw.clipId === "string") region.clipId = raw.clipId;
+	if (typeof raw.assetId === "string") region.assetId = raw.assetId;
+	if (typeof raw.sourceStartSec === "number" && Number.isFinite(raw.sourceStartSec)) {
+		region.sourceStartSec = raw.sourceStartSec;
+	}
+	if (typeof raw.sourceEndSec === "number" && Number.isFinite(raw.sourceEndSec)) {
+		region.sourceEndSec = raw.sourceEndSec;
+	}
+}
+
+function normalizeRegion(raw: unknown): AnchoredCameraLayoutRegion | null {
+	if (!isRecord(raw) || !isTemplate(raw.template)) return null;
+	const { id, startMs, endMs } = raw;
+	if (typeof id !== "string") return null;
+	if (typeof startMs !== "number" || typeof endMs !== "number") return null;
+	if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || startMs >= endMs) return null;
+	const template = raw.template;
+	const slots = normalizeSlots(raw.slots, template);
+	if (slots.length < TEMPLATE_SLOTS[template].min) return null;
+	const region: AnchoredCameraLayoutRegion = { id, startMs, endMs, template, slots };
+	copyAnchor(raw, region);
+	// The desk-view fields belong to camera 1's Full Camera alone; another camera's
+	// camera-full draws through the layout path, which ignores them.
+	if (isFullCameraLayout(region)) {
+		const rotation = normalizeCameraRotation(raw.rotation);
+		const mirror = normalizeCameraMirror(raw.mirror);
+		if (rotation !== 0) region.rotation = rotation;
+		if (mirror !== "auto") region.mirror = mirror;
+		if (raw.deskLabel === false) region.deskLabel = false;
+	}
+	return region;
+}
+
+function normalizeAll(raw: unknown): AnchoredCameraLayoutRegion[] {
+	if (!Array.isArray(raw)) return [];
+	return raw
+		.map(normalizeRegion)
+		.filter((r): r is AnchoredCameraLayoutRegion => r !== null)
+		.sort((a, b) => a.startMs - b.startMs);
+}
+
+/**
+ * Reads stored layout regions defensively: invalid ones are dropped, and a later row that
+ * overlaps an earlier one in this list is dropped too. A `camera-full` row of camera 1 is
+ * dropped as well: that section is stored in `cameraFullscreenRegions`, never here. Overlaps
+ * with that other list are prevented by the editor, not repaired here.
+ */
+export function normalizeCameraLayoutRegions(raw: unknown): AnchoredCameraLayoutRegion[] {
+	const kept: AnchoredCameraLayoutRegion[] = [];
+	for (const region of normalizeAll(raw)) {
+		if (isFullCameraLayout(region)) continue;
+		const last = kept[kept.length - 1];
+		if (last && region.startMs < last.endMs) continue;
+		kept.push(region);
+	}
+	return kept;
+}
+
+/**
+ * The rows of a camera-lane list that the span `[startMs, endMs)` overlaps. Full Camera and
+ * layout sections share one lane and may never overlap each other, so every writer that
+ * places a section (editor and agent) asks this before writing. Touching is not overlap.
+ */
+export function cameraSectionsOverlapping<T extends { startMs: number; endMs: number }>(
+	rows: readonly T[],
+	startMs: number,
+	endMs: number,
+): T[] {
+	return rows.filter((r) => r.startMs < endMs && r.endMs > startMs);
+}
+
+/**
+ * The `camera-full` rows of camera 1 that a hand-written `cameraLayoutRegions` list may
+ * still carry. The editor never writes them; the scene turns them into Full Camera regions.
+ */
+export function fullCameraRowsOfLayoutList(raw: unknown): AnchoredCameraLayoutRegion[] {
+	return normalizeAll(raw).filter(isFullCameraLayout);
+}
+
+function normalizeCrop(raw: unknown): CropRegion | undefined {
+	if (!isRecord(raw)) return undefined;
+	const { x, y, width, height } = raw;
+	if (
+		!inRange(x, 0, 1) ||
+		!inRange(y, 0, 1) ||
+		!inRange(width, 0, 1) ||
+		!inRange(height, 0, 1) ||
+		width <= 0 ||
+		height <= 0
+	) {
+		return undefined;
+	}
+	return { x, y, width, height };
+}
+
+function normalizePerspective(raw: unknown): CameraPerspective | undefined {
+	if (!isRecord(raw) || !Array.isArray(raw.corners) || raw.corners.length !== 4) return undefined;
+	const corners: { x: number; y: number }[] = [];
+	for (const c of raw.corners) {
+		if (!isRecord(c) || !inRange(c.x, RECT_MIN, RECT_MAX) || !inRange(c.y, RECT_MIN, RECT_MAX)) {
+			return undefined;
+		}
+		corners.push({ x: c.x, y: c.y });
+	}
+	if (!inRange(raw.aspect, 0.1, 10)) return undefined;
+	const perspective: CameraPerspective = {
+		corners: corners as CameraPerspective["corners"],
+		aspect: raw.aspect,
+	};
+	if (typeof raw.margin === "number" && Number.isFinite(raw.margin)) {
+		perspective.margin = Math.min(MAX_MARGIN, Math.max(0, raw.margin));
+	}
+	return perspective;
+}
+
+function normalizeOneCameraSettings(raw: unknown): CameraSettings | null {
+	if (!isRecord(raw)) return null;
+	const settings: CameraSettings = {};
+	const rotation = normalizeCameraRotation(raw.rotation);
+	if (rotation !== 0) settings.rotation = rotation;
+	if (typeof raw.mirror === "boolean") settings.mirror = raw.mirror;
+	const crop = normalizeCrop(raw.crop);
+	if (crop) settings.crop = crop;
+	const perspective = normalizePerspective(raw.perspective);
+	if (perspective) settings.perspective = perspective;
+	return settings;
+}
+
+/** Per-camera settings, index = camera (0 = camera 1); at most `MAX_CAMERAS` entries. */
+export function normalizeCameraSettings(raw: unknown): (CameraSettings | null)[] {
+	if (!Array.isArray(raw)) return [];
+	return raw.slice(0, MAX_CAMERAS).map(normalizeOneCameraSettings);
+}
+
+/**
+ * `legacyEditor.cameraSettings` after a change to one camera. `patch: null` resets the camera;
+ * a key set to `undefined` removes it. Defaults (rotation 0, mirror off) are not stored, and
+ * camera 1 (index 0) keeps only `perspective` -- its other settings live in the older fields.
+ * Returns `undefined` when nothing is left to store (the key is then deleted).
+ */
+export function patchCameraSettings(
+	raw: unknown,
+	index: number,
+	patch: Partial<CameraSettings> | null,
+): (CameraSettings | null)[] | undefined {
+	if (!Number.isInteger(index) || index < 0 || index >= MAX_CAMERAS) {
+		return normalizeCameraSettings(raw).length > 0 ? normalizeCameraSettings(raw) : undefined;
+	}
+	const list = normalizeCameraSettings(raw);
+	while (list.length <= index) list.push(null);
+	let merged: CameraSettings = {};
+	if (patch !== null) {
+		merged = { ...(list[index] ?? {}) };
+		for (const key of Object.keys(patch) as (keyof CameraSettings)[]) {
+			if (index === 0 && key !== "perspective") continue;
+			if (patch[key] === undefined) delete merged[key];
+			else Object.assign(merged, { [key]: patch[key] });
+		}
+		if (merged.rotation === 0) delete merged.rotation;
+		if (merged.mirror === false) delete merged.mirror;
+	}
+	list[index] = Object.keys(merged).length > 0 ? merged : null;
+	while (list.length > 0 && list[list.length - 1] === null) list.pop();
+	return list.length > 0 ? list : undefined;
+}
diff --git a/src/lib/cameraPerspective.test.ts b/src/lib/cameraPerspective.test.ts
new file mode 100644
index 000000000..881c7dd2b
--- /dev/null
+++ b/src/lib/cameraPerspective.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import { homographyFromUnitSquare, perspectiveMatrix } from "./cameraPerspective";
+
+const apply = (h: number[], u: number, v: number) => {
+	const w = h[6] * u + h[7] * v + h[8];
+	return [(h[0] * u + h[1] * v + h[2]) / w, (h[3] * u + h[4] * v + h[5]) / w];
+};
+const quad = [
+	{ x: 0.2, y: 0.3 },
+	{ x: 0.85, y: 0.25 },
+	{ x: 0.95, y: 0.9 },
+	{ x: 0.1, y: 0.8 },
+] as const;
+
+describe("homographyFromUnitSquare", () => {
+	it("maps the unit square's corners onto the four points", () => {
+		const h = homographyFromUnitSquare([...quad] as never);
+		expect(h).not.toBeNull();
+		const corners = [
+			[0, 0],
+			[1, 0],
+			[1, 1],
+			[0, 1],
+		];
+		corners.forEach(([u, v], i) => {
+			const [x, y] = apply(h as number[], u, v);
+			expect(x).toBeCloseTo(quad[i].x, 9);
+			expect(y).toBeCloseTo(quad[i].y, 9);
+		});
+	});
+	it("is the identity for the full image", () => {
+		const h = homographyFromUnitSquare([
+			{ x: 0, y: 0 },
+			{ x: 1, y: 0 },
+			{ x: 1, y: 1 },
+			{ x: 0, y: 1 },
+		]);
+		expect(h?.map((n) => Number(n.toFixed(12)))).toEqual([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+	});
+	it("rejects collinear and crossed quads", () => {
+		expect(
+			homographyFromUnitSquare([
+				{ x: 0, y: 0 },
+				{ x: 0.5, y: 0 },
+				{ x: 1, y: 0 },
+				{ x: 0, y: 1 },
+			]),
+		).toBeNull();
+		// bow-tie: top-right and bottom-right swapped
+		expect(
+			homographyFromUnitSquare([
+				{ x: 0, y: 0 },
+				{ x: 1, y: 1 },
+				{ x: 1, y: 0 },
+				{ x: 0, y: 1 },
+			]),
+		).toBeNull();
+	});
+});
+
+describe("perspectiveMatrix", () => {
+	it("folds the margin in: the target edge lands outside the quad", () => {
+		const h = perspectiveMatrix({ corners: [...quad] as never, aspect: 297 / 210, margin: 0.1 });
+		const inner = perspectiveMatrix({ corners: [...quad] as never, aspect: 297 / 210 });
+		expect(h).not.toBeNull();
+		// the target point that maps to the quad's top-left corner moves inward by the margin
+		const [x, y] = apply(h as number[], 0.1 / 1.2, 0.1 / 1.2);
+		expect(x).toBeCloseTo(quad[0].x, 9);
+		expect(y).toBeCloseTo(quad[0].y, 9);
+		expect(apply(inner as number[], 0, 0)[0]).toBeCloseTo(quad[0].x, 9);
+	});
+	it("returns null for a degenerate quad", () => {
+		expect(
+			perspectiveMatrix({
+				corners: [
+					{ x: 0, y: 0 },
+					{ x: 0.5, y: 0 },
+					{ x: 1, y: 0 },
+					{ x: 0, y: 1 },
+				],
+				aspect: 1.5,
+			}),
+		).toBeNull();
+	});
+});
diff --git a/src/lib/cameraPerspective.ts b/src/lib/cameraPerspective.ts
new file mode 100644
index 000000000..2a156915a
--- /dev/null
+++ b/src/lib/cameraPerspective.ts
@@ -0,0 +1,67 @@
+import type { CameraPerspective } from "@/components/video-editor/types";
+
+type Corners = CameraPerspective["corners"];
+
+/** True when the quad is strictly convex: every turn has the same non-zero direction. */
+function isConvexClockwiseOrCounter(c: Corners): boolean {
+	let sign = 0;
+	for (let i = 0; i < 4; i++) {
+		const a = c[i];
+		const b = c[(i + 1) % 4];
+		const d = c[(i + 2) % 4];
+		const z = (b.x - a.x) * (d.y - b.y) - (b.y - a.y) * (d.x - b.x);
+		if (!Number.isFinite(z) || Math.abs(z) <= 1e-9) return false;
+		const s = z > 0 ? 1 : -1;
+		if (sign === 0) sign = s;
+		else if (s !== sign) return false;
+	}
+	return true;
+}
+
+/**
+ * Homography (row-major 3x3) mapping the unit square (0,0),(1,0),(1,1),(0,1) onto the four
+ * points, in that order (Heckbert's closed form). Maps (u,v,1) in the target picture to the
+ * point in the source camera image. Null for a degenerate or non-convex quad.
+ */
+export function homographyFromUnitSquare(c: Corners): number[] | null {
+	if (!isConvexClockwiseOrCounter(c)) return null;
+	const [p0, p1, p2, p3] = c;
+	const dx1 = p1.x - p2.x;
+	const dx2 = p3.x - p2.x;
+	const dx3 = p0.x - p1.x + p2.x - p3.x;
+	const dy1 = p1.y - p2.y;
+	const dy2 = p3.y - p2.y;
+	const dy3 = p0.y - p1.y + p2.y - p3.y;
+	let g = 0;
+	let h = 0;
+	if (Math.abs(dx3) > 1e-12 || Math.abs(dy3) > 1e-12) {
+		const den = dx1 * dy2 - dx2 * dy1;
+		if (Math.abs(den) < 1e-12) return null;
+		g = (dx3 * dy2 - dx2 * dy3) / den;
+		h = (dx1 * dy3 - dx3 * dy1) / den;
+	}
+	const a = p1.x - p0.x + g * p1.x;
+	const b = p3.x - p0.x + h * p3.x;
+	const d = p1.y - p0.y + g * p1.y;
+	const e = p3.y - p0.y + h * p3.y;
+	return [a, b, p0.x, d, e, p0.y, g, h, 1];
+}
+
+/**
+ * The homography with the margin folded in: the output's local [0,1]^2 maps to
+ * [-m, 1+m]^2 of the quad, so the picture shows a border around the marked subject.
+ * `aspect` is not part of the matrix; it sets the layer's box ratio.
+ */
+export function perspectiveMatrix(p: CameraPerspective): number[] | null {
+	const h = homographyFromUnitSquare(p.corners);
+	if (!h) return null;
+	const m = p.margin ?? 0;
+	const s = [1 + 2 * m, 0, -m, 0, 1 + 2 * m, -m, 0, 0, 1];
+	const out: number[] = [];
+	for (let r = 0; r < 3; r++) {
+		for (let col = 0; col < 3; col++) {
+			out.push(h[r * 3] * s[col] + h[r * 3 + 1] * s[3 + col] + h[r * 3 + 2] * s[6 + col]);
+		}
+	}
+	return out;
+}
diff --git a/src/lib/markerSheet.test.ts b/src/lib/markerSheet.test.ts
new file mode 100644
index 000000000..7fc6dc7c3
--- /dev/null
+++ b/src/lib/markerSheet.test.ts
@@ -0,0 +1,106 @@
+// @vitest-environment jsdom
+// jsdom for `printMarkerSheet` (iframe) and for parsing the sheet with DOMParser.
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { markerBits } from "./arucoMarkers";
+import {
+	MARKER_SIZE_MM,
+	markerSheetSvg,
+	PRINT_FRAME_FALLBACK_MS,
+	printMarkerSheet,
+} from "./markerSheet";
+
+function parse(svg: string): Document {
+	return new DOMParser().parseFromString(svg, "image/svg+xml");
+}
+
+const num = (el: Element, name: string) => Number(el.getAttribute(name));
+
+describe("markerSheetSvg", () => {
+	it("is an A4 portrait page in millimetres", () => {
+		const root = parse(markerSheetSvg()).documentElement;
+		expect(root.getAttribute("width")).toBe("210mm");
+		expect(root.getAttribute("height")).toBe("297mm");
+		expect(root.getAttribute("viewBox")).toBe("0 0 210 297");
+	});
+
+	it("the sheet contains markers 0–3 at 40 mm", () => {
+		const doc = parse(markerSheetSvg());
+		const groups = [...doc.querySelectorAll("g[data-marker-id]")];
+		expect(groups.map((g) => g.getAttribute("data-marker-id"))).toEqual(["0", "1", "2", "3"]);
+		for (const g of groups) {
+			const id = Number(g.getAttribute("data-marker-id"));
+			const square = g.querySelector("rect[data-marker-size]");
+			if (!square) throw new Error(`marker ${id} has no square`);
+			expect(num(square, "width")).toBe(MARKER_SIZE_MM);
+			expect(num(square, "height")).toBe(MARKER_SIZE_MM);
+			// Read the white cells back: they are the dictionary's bits for this ID.
+			const cell = MARKER_SIZE_MM / 6;
+			const read = Array.from({ length: 4 }, () => Array<boolean>(4).fill(false));
+			for (const r of g.querySelectorAll("rect[data-cell]")) {
+				const col = Math.round((num(r, "x") - num(square, "x")) / cell) - 1;
+				const row = Math.round((num(r, "y") - num(square, "y")) / cell) - 1;
+				read[row][col] = true;
+			}
+			expect(read).toEqual(markerBits(id));
+		}
+	});
+
+	it("prints the caller's texts, escaped", () => {
+		const svg = markerSheetSvg({
+			instruction: "Cut <here> & lay",
+			labels: ["a", "b", "c", "d"],
+		});
+		const doc = parse(svg);
+		expect(doc.querySelector("parsererror")).toBeNull();
+		const texts = [...doc.querySelectorAll("text")].map((t) => t.textContent);
+		expect(texts).toEqual(["Cut <here> & lay", "a", "b", "c", "d"]);
+	});
+});
+
+describe("printMarkerSheet", () => {
+	afterEach(() => {
+		for (const f of document.querySelectorAll("iframe")) f.remove();
+		vi.useRealTimers();
+	});
+
+	function loadAndPrint(iframe: HTMLIFrameElement) {
+		const win = iframe.contentWindow;
+		if (!win) throw new Error("no iframe window");
+		vi.spyOn(win, "focus").mockImplementation(() => undefined);
+		const print = vi.spyOn(win, "print").mockImplementation(() => undefined);
+		iframe.dispatchEvent(new Event("load"));
+		return print;
+	}
+
+	it("prints the sheet from a hidden iframe and removes it afterwards", () => {
+		printMarkerSheet();
+		const iframe = document.querySelector("iframe");
+		if (!iframe?.contentWindow) throw new Error("no iframe");
+		expect(iframe.srcdoc).toContain("<svg");
+		const win = iframe.contentWindow;
+		vi.spyOn(win, "focus").mockImplementation(() => undefined);
+		const print = vi.spyOn(win, "print").mockImplementation(() => undefined);
+		iframe.dispatchEvent(new Event("load"));
+		expect(print).toHaveBeenCalledTimes(1);
+		win.dispatchEvent(new Event("afterprint"));
+		expect(document.querySelector("iframe")).toBeNull();
+	});
+
+	it("a second click replaces the first iframe instead of stacking another", () => {
+		printMarkerSheet();
+		printMarkerSheet();
+		expect(document.querySelectorAll("iframe")).toHaveLength(1);
+	});
+
+	it("removes the iframe after a timeout when afterprint never fires", () => {
+		vi.useFakeTimers();
+		printMarkerSheet();
+		const iframe = document.querySelector("iframe");
+		if (!iframe) throw new Error("no iframe");
+		expect(loadAndPrint(iframe)).toHaveBeenCalledTimes(1);
+		vi.advanceTimersByTime(PRINT_FRAME_FALLBACK_MS - 1);
+		expect(document.querySelector("iframe")).not.toBeNull();
+		vi.advanceTimersByTime(1);
+		expect(document.querySelector("iframe")).toBeNull();
+	});
+});
diff --git a/src/lib/markerSheet.ts b/src/lib/markerSheet.ts
new file mode 100644
index 000000000..37aa60920
--- /dev/null
+++ b/src/lib/markerSheet.ts
@@ -0,0 +1,144 @@
+// The printable marker sheet: an A4 page with the four corner markers (IDs 0–3, 40 mm each)
+// drawn from the dictionary the detector reads, cut lines around each, a label per marker and a
+// one-line instruction. Printed through a hidden iframe and the browser's print dialog, which
+// also offers "Save as PDF" — no file IPC needed.
+
+import { CORNER_MARKER_IDS, markerBits } from "./arucoMarkers";
+
+export const SHEET_WIDTH_MM = 210;
+export const SHEET_HEIGHT_MM = 297;
+/** Marker side including its black border. */
+export const MARKER_SIZE_MM = 40;
+
+/** The texts printed on the sheet; the caller passes them translated. */
+export interface MarkerSheetText {
+	instruction: string;
+	/** One label per marker, in ID order (top-left, top-right, bottom-right, bottom-left). */
+	labels: [string, string, string, string];
+}
+
+const DEFAULT_TEXT: MarkerSheetText = {
+	instruction: "Cut along the dashed lines. Put each marker's inner corner on its labelled corner.",
+	labels: ["0 – top-left", "1 – top-right", "2 – bottom-right", "3 – bottom-left"],
+};
+
+/** Each marker's top-left on the page (mm), by ID. */
+const MARKER_ORIGINS_MM: ReadonlyArray<{ x: number; y: number }> = [
+	{ x: 35, y: 55 },
+	{ x: 135, y: 55 },
+	{ x: 135, y: 175 },
+	{ x: 35, y: 175 },
+];
+
+function mm(value: number): string {
+	return String(Math.round(value * 1000) / 1000);
+}
+
+function escapeXml(text: string): string {
+	return text
+		.replace(/&/g, "&amp;")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;");
+}
+
+function markerSvg(id: number, x: number, y: number, label: string): string {
+	const bits = markerBits(id);
+	const cell = MARKER_SIZE_MM / (bits.length + 2);
+	const parts: string[] = [];
+	// Cut line one cell outside the marker: the white quiet zone the detector needs.
+	parts.push(
+		`<rect x="${mm(x - cell)}" y="${mm(y - cell)}" width="${mm(MARKER_SIZE_MM + 2 * cell)}" height="${mm(MARKER_SIZE_MM + 2 * cell)}" fill="none" stroke="#888" stroke-width="0.2" stroke-dasharray="2 1.5"/>`,
+	);
+	parts.push(
+		`<rect data-marker-size="${mm(MARKER_SIZE_MM)}" x="${mm(x)}" y="${mm(y)}" width="${mm(MARKER_SIZE_MM)}" height="${mm(MARKER_SIZE_MM)}" fill="#000"/>`,
+	);
+	bits.forEach((row, r) => {
+		row.forEach((white, c) => {
+			if (!white) return;
+			parts.push(
+				`<rect data-cell="${r},${c}" x="${mm(x + (c + 1) * cell)}" y="${mm(y + (r + 1) * cell)}" width="${mm(cell)}" height="${mm(cell)}" fill="#fff"/>`,
+			);
+		});
+	});
+	parts.push(
+		`<text x="${mm(x + MARKER_SIZE_MM / 2)}" y="${mm(y + MARKER_SIZE_MM + 2 * cell + 5)}" font-size="4" text-anchor="middle" fill="#444">${escapeXml(label)}</text>`,
+	);
+	return `<g data-marker-id="${id}" shape-rendering="crispEdges">${parts.join("")}</g>`;
+}
+
+/** The sheet as an SVG document string: A4 portrait, user units are millimetres. */
+export function markerSheetSvg(text: MarkerSheetText = DEFAULT_TEXT): string {
+	const markers = CORNER_MARKER_IDS.map((id, i) =>
+		markerSvg(id, MARKER_ORIGINS_MM[i].x, MARKER_ORIGINS_MM[i].y, text.labels[i]),
+	).join("");
+	return (
+		`<svg xmlns="http://www.w3.org/2000/svg" width="${SHEET_WIDTH_MM}mm" height="${SHEET_HEIGHT_MM}mm" viewBox="0 0 ${SHEET_WIDTH_MM} ${SHEET_HEIGHT_MM}" font-family="sans-serif">` +
+		`<rect width="${SHEET_WIDTH_MM}" height="${SHEET_HEIGHT_MM}" fill="#fff"/>` +
+		`<text x="${SHEET_WIDTH_MM / 2}" y="25" font-size="3.5" text-anchor="middle" fill="#000">${escapeXml(text.instruction)}</text>` +
+		markers +
+		"</svg>"
+	);
+}
+
+/** The page the iframe prints: the sheet at its true size, no browser margins. */
+export function markerSheetHtml(text?: MarkerSheetText): string {
+	return (
+		'<!doctype html><html><head><meta charset="utf-8"><title>ArUco</title>' +
+		"<style>@page{size:A4 portrait;margin:0}html,body{margin:0;padding:0;background:#fff}svg{display:block}</style>" +
+		`</head><body>${markerSheetSvg(text)}</body></html>`
+	);
+}
+
+/** Marks the iframe so a second click replaces it instead of stacking another one. */
+const PRINT_FRAME_ATTR = "data-marker-sheet-print";
+
+/**
+ * Removal fallback for when `afterprint` never fires (a dialog that never opened, a print
+ * cancelled in a way the frame does not report). Counted from the moment `print()` returns.
+ */
+export const PRINT_FRAME_FALLBACK_MS = 60_000;
+
+/**
+ * Opens the print dialog for the sheet (the OS dialog offers "Save as PDF"). A hidden iframe
+ * carries the page so the editor itself is not printed; it goes away once printing is done.
+ * Only one such iframe exists at a time: a repeated call replaces the previous one.
+ */
+export function printMarkerSheet(text?: MarkerSheetText): void {
+	for (const old of document.querySelectorAll(`iframe[${PRINT_FRAME_ATTR}]`)) old.remove();
+	const iframe = document.createElement("iframe");
+	iframe.setAttribute(PRINT_FRAME_ATTR, "");
+	iframe.setAttribute("aria-hidden", "true");
+	iframe.tabIndex = -1;
+	Object.assign(iframe.style, {
+		position: "fixed",
+		right: "0",
+		bottom: "0",
+		width: "0",
+		height: "0",
+		border: "0",
+	});
+	let fallback: ReturnType<typeof setTimeout> | undefined;
+	const remove = () => {
+		if (fallback !== undefined) clearTimeout(fallback);
+		fallback = undefined;
+		iframe.remove();
+	};
+	iframe.addEventListener(
+		"load",
+		() => {
+			const win = iframe.contentWindow;
+			if (!win) {
+				remove();
+				return;
+			}
+			win.addEventListener("afterprint", remove, { once: true });
+			win.focus();
+			win.print();
+			fallback = setTimeout(remove, PRINT_FRAME_FALLBACK_MS);
+		},
+		{ once: true },
+	);
+	iframe.srcdoc = markerSheetHtml(text);
+	document.body.appendChild(iframe);
+}
diff --git a/src/native/compositorViewClient.ts b/src/native/compositorViewClient.ts
index 66f63ce56..71594af45 100644
--- a/src/native/compositorViewClient.ts
+++ b/src/native/compositorViewClient.ts
@@ -11,6 +11,7 @@ import { requireNativeBridgeData } from "./client";
 import type {
 	CompositorBackend,
 	CompositorBackendResult,
+	CompositorClipCamera,
 	CompositorClipInput,
 	CompositorExportGifParams,
 	CompositorExportGifResult,
@@ -175,11 +176,20 @@ export function setActiveClip(
 	webcamOffsetSec: number,
 	clipIndex: number,
 	sourceTimeSec: number,
+	additionalCameras: CompositorClipCamera[] = [],
 ): Promise<{ ok: true }> {
 	return requireNativeBridgeData<{ ok: true }>({
 		domain: "compositor",
 		action: "setActiveClip",
-		payload: { id, screenPath, webcamPath, webcamOffsetSec, clipIndex, sourceTimeSec },
+		payload: {
+			id,
+			screenPath,
+			webcamPath,
+			webcamOffsetSec,
+			clipIndex,
+			sourceTimeSec,
+			additionalCameras,
+		},
 	});
 }
 
diff --git a/src/native/contracts.ts b/src/native/contracts.ts
index 5421b994a..59c150ad7 100644
--- a/src/native/contracts.ts
+++ b/src/native/contracts.ts
@@ -192,6 +192,14 @@ export interface CompositorSharedFrameReceipt extends CompositorSharedFrameMeta
 	shared: true;
 }
 
+/** An additional camera (2-4) of a clip. Index k-1 in `additionalCameras` = camera k. */
+export interface CompositorClipCamera {
+	/** "" = no camera in this slot (hidden or missing), exactly like `webcamPath`. */
+	path: string;
+	/** Camera source time = screen source time − this. */
+	offsetSec: number;
+}
+
 /** Un clip de la timeline pour l'export multiclip natif (fichiers screen+webcam + trim). */
 export interface CompositorClipInput {
 	screenPath: string;
@@ -206,6 +214,8 @@ export interface CompositorClipInput {
 	 *  convention). Populated by `buildSceneDescription` and `buildNativeClipList`;
 	 *  see the comment on the producer side for the exact rule. */
 	hasAudio: boolean;
+	/** Cameras 2-4; omitted when the clip has none. */
+	additionalCameras?: CompositorClipCamera[];
 }
 
 /** Bilan d'un export natif (mesure enveloppante §10 : frames, durée, fps). */
@@ -906,6 +916,8 @@ export type NativeBridgeRequest =
 				clipIndex: number;
 				/** Current screen-source time within the active clip's source window. */
 				sourceTimeSec: number;
+				/** Cameras 2-4 of the clip; the view decodes only those its layout regions show. */
+				additionalCameras?: CompositorClipCamera[];
 			};
 			requestId?: string;
 	  }
diff --git a/src/native/sceneDescription.test.ts b/src/native/sceneDescription.test.ts
index 365c1c995..ead400646 100644
--- a/src/native/sceneDescription.test.ts
+++ b/src/native/sceneDescription.test.ts
@@ -6,6 +6,7 @@
 // crop / settings mapping / output dims).
 
 import { describe, expect, it, vi } from "vitest";
+import type { CameraPerspective } from "@/components/video-editor/types";
 import {
 	DEFAULT_CROP_REGION,
 	getZoomScale,
@@ -27,6 +28,7 @@ import {
 	annotationFootageRect,
 	buildSceneDescription,
 	wallpaperAcceptsMotion,
+	webcamBoxSourceSize,
 	zoomScaleLimit,
 } from "./sceneDescription";
 
@@ -938,6 +940,75 @@ describe("buildSceneDescription.cameraFullscreenRegions", () => {
 		expect(labels.map((a) => [a.startSec, a.endSec])).toEqual([[0, 20]]);
 	});
 
+	it("a hand-written camera-1 camera-full layout row is not doubled", () => {
+		// The editor stores camera 1's Full Camera only in `cameraFullscreenRegions`. A
+		// hand-written layout row for the same span must not emit a second section.
+		const section = { id: "cf1", startMs: 0, endMs: 20_000, rotation: 180 };
+		const doc = makeDoc({
+			legacyEditor: {
+				cameraFullscreenRegions: [section],
+				cameraLayoutRegions: [
+					{ ...section, id: "l1", template: "camera-full", slots: [{ camera: 0 }] },
+				],
+			},
+		});
+		const scene = buildSceneDescription(doc);
+		expect(scene.cameraFullscreenRegions).toHaveLength(1);
+		const labels = scene.annotations.filter((a) => a.text?.animation === DESK_COVER_ANIMATION);
+		expect(labels.map((a) => a.id)).toEqual(["desk-cf1-all"]);
+		// An empty layout list no longer hides the Full Camera regions.
+		const emptied = makeDoc({
+			legacyEditor: { cameraFullscreenRegions: [section], cameraLayoutRegions: [] },
+		});
+		expect(buildSceneDescription(emptied).cameraFullscreenRegions).toHaveLength(1);
+	});
+
+	it("a label that meets a layout region still spans its whole section", () => {
+		// A turned section right before a camera-full-pip region: the compositor holds no cover
+		// over a shrink there (`full_camera_seams`). The label needs no seam rule of its own: it
+		// is drawn at the cover's strength, so it spans the section and the cover decides.
+		const asset = makeAsset({
+			id: "a",
+			originalPath: "/a.mp4",
+			cameraTrack: { sourcePath: "/w-1.mp4", startMs: 0, offsetMs: 0, visible: true },
+			additionalCameraTracks: [
+				{ sourcePath: "/w-2.mp4", startMs: 0, offsetMs: 0, visible: true, label: "Desk" },
+			],
+		});
+		const clip = makeClip({
+			id: "c1",
+			assetId: "a",
+			sourceStartSec: 0,
+			sourceEndSec: 30,
+			timelineStartSec: 0,
+			timelineEndSec: 30,
+		});
+		const section = {
+			id: "cf1",
+			startMs: 0,
+			endMs: 10_000,
+			rotation: 180,
+			template: "camera-full",
+			slots: [{ camera: 0 }],
+		};
+		const pip = {
+			id: "l1",
+			startMs: 10_000,
+			endMs: 20_000,
+			template: "camera-full-pip",
+			slots: [{ camera: 1 }, { camera: 0 }],
+		};
+		const doc = makeDoc({
+			assets: [asset],
+			clips: [clip],
+			legacyEditor: { cameraLayoutRegions: [section, pip] },
+		});
+		const scene = buildSceneDescription(doc);
+		expect(scene.cameraLayoutRegions?.map((l) => [l.startSec, l.endSec])).toEqual([[10, 20]]);
+		const labels = scene.annotations.filter((a) => a.text?.animation === DESK_COVER_ANIMATION);
+		expect(labels.map((a) => [a.startSec, a.endSec])).toEqual([[0, 10]]);
+	});
+
 	it("no label for a plain section or with the label off", () => {
 		for (const region of [
 			{ id: "cf1", startMs: 0, endMs: 20_000 },
@@ -3031,3 +3102,367 @@ describe("buildSceneDescription.audioTracks", () => {
 		expect(buildSceneDescription(doc).audioTracks).toEqual([]);
 	});
 });
+
+// --- extra cameras, camera settings and layout regions ----------------------
+
+describe("buildSceneDescription cameras", () => {
+	const extra = { sourcePath: "/w-2.mp4", startMs: 0, offsetMs: 120, visible: true, label: "Desk" };
+	const docWith = (
+		assetOverrides: Partial<AxcutAsset>,
+		legacyEditor: Record<string, unknown> | null,
+	) => {
+		const asset = makeAsset({
+			id: "a",
+			originalPath: "/screen.mp4",
+			cameraTrack: { sourcePath: "/w-1.mp4", startMs: 0, offsetMs: 0, visible: true },
+			...assetOverrides,
+		});
+		const clip = makeClip({
+			id: "c1",
+			assetId: "a",
+			sourceStartSec: 0,
+			sourceEndSec: 10,
+			timelineStartSec: 0,
+			timelineEndSec: 10,
+		});
+		return makeDoc({ assets: [asset], clips: [clip], legacyEditor });
+	};
+	const layoutRegion = (template: string, slots: unknown[], extraFields = {}) => ({
+		id: "a",
+		startMs: 1000,
+		endMs: 4000,
+		template,
+		slots,
+		...extraFields,
+	});
+
+	it("a project without camera layouts produces the same scene as before", () => {
+		const scene = buildSceneDescription(docWith({}, null));
+		expect(scene.cameras).toBeUndefined();
+		expect(scene.cameraLayoutRegions).toBeUndefined();
+		for (const clip of scene.clips) expect("additionalCameras" in clip).toBe(false);
+	});
+
+	it("extra camera tracks become clip cameras", () => {
+		const scene = buildSceneDescription(docWith({ additionalCameraTracks: [extra] }, null));
+		expect(scene.clips[0].additionalCameras).toEqual([{ path: "/w-2.mp4", offsetSec: 0.12 }]);
+	});
+
+	it("a camera-full region for camera 1 stays a Full Camera region", () => {
+		const scene = buildSceneDescription(
+			docWith(
+				{},
+				{
+					cameraLayoutRegions: [layoutRegion("camera-full", [{ camera: 0 }], { rotation: 180 })],
+				},
+			),
+		);
+		expect(scene.cameraFullscreenRegions).toMatchObject([
+			{ startSec: 1, endSec: 4, rotation: 180 },
+		]);
+		expect(scene.cameraLayoutRegions).toBeUndefined();
+	});
+
+	it("legacy full camera regions still reach the scene next to layout regions", () => {
+		const scene = buildSceneDescription(
+			docWith(
+				{ additionalCameraTracks: [extra] },
+				{
+					cameraFullscreenRegions: [{ id: "cf1", startMs: 1000, endMs: 3000 }],
+					cameraLayoutRegions: [
+						layoutRegion("screen-pip", [{ camera: 1 }], { startMs: 4000, endMs: 6000 }),
+					],
+				},
+			),
+		);
+		expect(scene.cameraFullscreenRegions).toMatchObject([{ startSec: 1, endSec: 3 }]);
+		expect(scene.cameraLayoutRegions).toHaveLength(1);
+		expect(scene.cameraLayoutRegions?.[0]).toMatchObject({ startSec: 4, endSec: 6 });
+	});
+
+	it("a layout region follows its clip", () => {
+		const asset = makeAsset({
+			id: "a",
+			originalPath: "/screen.mp4",
+			cameraTrack: { sourcePath: "/w-1.mp4", startMs: 0, offsetMs: 0, visible: true },
+			additionalCameraTracks: [extra],
+		});
+		const clips = [
+			makeClip({
+				id: "c1",
+				assetId: "a",
+				sourceStartSec: 0,
+				sourceEndSec: 10,
+				timelineStartSec: 0,
+				timelineEndSec: 10,
+			}),
+			makeClip({
+				id: "c2",
+				assetId: "a",
+				sourceStartSec: 20,
+				sourceEndSec: 30,
+				timelineStartSec: 10,
+				timelineEndSec: 20,
+			}),
+		];
+		// The ms cache still says 2-4 s (where c2 sat before it moved behind c1); the anchor
+		// says c2's source 22-24 s, and that is what the scene must follow.
+		const row = layoutRegion("screen-pip", [{ camera: 1 }], {
+			startMs: 2000,
+			endMs: 4000,
+			clipId: "c2",
+			assetId: "a",
+			sourceStartSec: 22,
+			sourceEndSec: 24,
+		});
+		const scene = buildSceneDescription(
+			makeDoc({ assets: [asset], clips, legacyEditor: { cameraLayoutRegions: [row] } }),
+		);
+		expect(scene.cameraLayoutRegions).toHaveLength(1);
+		expect(scene.cameraLayoutRegions?.[0]).toMatchObject({
+			startSec: 22,
+			endSec: 24,
+			clipIndex: 1,
+		});
+	});
+
+	it("a camera-full-pip region becomes resolved layers", () => {
+		const scene = buildSceneDescription(
+			docWith(
+				{ additionalCameraTracks: [extra] },
+				{
+					cameraLayoutRegions: [layoutRegion("camera-full-pip", [{ camera: 1 }, { camera: 0 }])],
+				},
+			),
+		);
+		expect(scene.cameraFullscreenRegions).toEqual([]);
+		expect(scene.cameraLayoutRegions).toHaveLength(1);
+		const [region] = scene.cameraLayoutRegions ?? [];
+		expect(region).toMatchObject({ startSec: 1, endSec: 4, clipIndex: 0 });
+		expect(region.layers.map((l) => [l.camera, l.fillsFrame])).toEqual([
+			[1, true],
+			[0, false],
+		]);
+	});
+
+	it("a degenerate perspective sends no homography", () => {
+		const collinear = [
+			{ x: 0, y: 0 },
+			{ x: 0.5, y: 0 },
+			{ x: 1, y: 0 },
+			{ x: 0.2, y: 0 },
+		];
+		const scene = buildSceneDescription(
+			docWith(
+				{ additionalCameraTracks: [extra] },
+				{ cameraSettings: [null, { perspective: { corners: collinear, aspect: 1.5 } }] },
+			),
+		);
+		// The camera draws uncorrected: its entry carries no matrix (and no settings at all).
+		expect(scene.cameras).toEqual([{ index: 1 }]);
+	});
+
+	it("a valid perspective sends the matrix and replaces rotation, mirror and crop", () => {
+		const corners = [
+			{ x: 0.1, y: 0.1 },
+			{ x: 0.9, y: 0.15 },
+			{ x: 0.85, y: 0.9 },
+			{ x: 0.15, y: 0.8 },
+		];
+		const scene = buildSceneDescription(
+			docWith(
+				{ additionalCameraTracks: [extra] },
+				{
+					cameraSettings: [
+						null,
+						{ rotation: 180, mirror: true, perspective: { corners, aspect: 1.5 } },
+					],
+				},
+			),
+		);
+		expect(scene.cameras).toHaveLength(1);
+		const [camera] = scene.cameras ?? [];
+		expect(camera.index).toBe(1);
+		expect(camera.homography).toHaveLength(9);
+		expect(camera.aspect).toBe(1.5);
+		expect(camera).not.toHaveProperty("rotation");
+		expect(camera).not.toHaveProperty("mirror");
+	});
+
+	it("plain settings are sent per camera index", () => {
+		const scene = buildSceneDescription(
+			docWith(
+				{ additionalCameraTracks: [extra] },
+				{
+					cameraSettings: [
+						null,
+						{ rotation: 180, mirror: false, crop: { x: 0, y: 0, width: 0.5, height: 1 } },
+					],
+				},
+			),
+		);
+		expect(scene.cameras).toEqual([
+			{ index: 1, rotation: 180, mirror: false, crop: { x: 0, y: 0, width: 0.5, height: 1 } },
+		]);
+	});
+
+	it("a layer for a camera the asset does not have is dropped", () => {
+		const scene = buildSceneDescription(
+			docWith(
+				{},
+				{
+					cameraLayoutRegions: [
+						layoutRegion("camera-full-pip", [{ camera: 1 }, { camera: 0 }]),
+						layoutRegion("camera-full", [{ camera: 2 }], { id: "b" }),
+					],
+				},
+			),
+		);
+		// The first keeps only camera 0; the second has no layer left and is dropped.
+		expect(scene.cameraLayoutRegions).toHaveLength(1);
+		expect(scene.cameraLayoutRegions?.[0].layers.map((l) => l.camera)).toEqual([0]);
+	});
+
+	it("a PiP in a clip without a camera-1 box keeps the project roundness", () => {
+		const scene = buildSceneDescription(
+			docWith(
+				{ additionalCameraTracks: [extra] },
+				{
+					webcamLayoutPreset: "no-webcam",
+					webcamRoundness: 0.6,
+					cameraLayoutRegions: [layoutRegion("camera-full-pip", [{ camera: 1 }, { camera: 0 }])],
+				},
+			),
+		);
+		const pip = scene.cameraLayoutRegions?.[0].layers.find((l) => l.camera === 0);
+		// Same unit as `computeCompositeLayout`: the radius is a fraction of the short side
+		// (= roundness of half of it).
+		expect(pip?.radiusFrac).toBeCloseTo(0.3, 6);
+	});
+
+	it("camera 1's box takes its perspective's aspect, in the default PiP and in a template", () => {
+		const corners = [
+			{ x: 0.1, y: 0.1 },
+			{ x: 0.9, y: 0.15 },
+			{ x: 0.85, y: 0.9 },
+			{ x: 0.15, y: 0.8 },
+		];
+		const scene = buildSceneDescription(
+			docWith(
+				{
+					cameraTrack: {
+						sourcePath: "/w-1.mp4",
+						startMs: 0,
+						offsetMs: 0,
+						visible: true,
+						width: 1920,
+						height: 1080,
+					},
+					additionalCameraTracks: [extra],
+				},
+				{
+					webcamMaskShape: "rectangle",
+					// The crop is ignored once the perspective is valid.
+					webcamCropRegion: { x: 0, y: 0, width: 0.5, height: 1 },
+					cameraSettings: [{ perspective: { corners, aspect: 4 / 3 } }],
+					cameraLayoutRegions: [layoutRegion("camera-full-pip", [{ camera: 1 }, { camera: 0 }])],
+				},
+			),
+		);
+		const { width, height } = scene.output;
+		const ratio = (rect: { width: number; height: number } | null | undefined) =>
+			((rect?.width ?? 0) * width) / ((rect?.height ?? 1) * height);
+		expect(ratio(scene.layout.webcamRect)).toBeCloseTo(4 / 3, 2);
+		expect(ratio(scene.layout.layoutByClip?.[0]?.webcamRect)).toBeCloseTo(4 / 3, 2);
+		const pip = scene.cameraLayoutRegions?.[0].layers.find((l) => l.camera === 0);
+		expect(ratio(pip?.rect)).toBeCloseTo(4 / 3, 2);
+	});
+
+	it("the box source size reads a valid perspective and ignores a degenerate one", () => {
+		const camera = { width: 1920, height: 1080 };
+		const crop = { width: 0.5, height: 1 };
+		const square: CameraPerspective = {
+			corners: [
+				{ x: 0, y: 0 },
+				{ x: 1, y: 0 },
+				{ x: 1, y: 1 },
+				{ x: 0, y: 1 },
+			],
+			aspect: 0.75,
+		};
+		const valid = webcamBoxSourceSize(camera, null, crop, square);
+		expect(valid.width / valid.height).toBeCloseTo(0.75, 3);
+		const collinear: CameraPerspective = {
+			corners: [
+				{ x: 0, y: 0 },
+				{ x: 0.5, y: 0 },
+				{ x: 1, y: 0 },
+				{ x: 0.2, y: 0 },
+			],
+			aspect: 0.75,
+		};
+		expect(webcamBoxSourceSize(camera, null, crop, collinear)).toEqual({
+			width: 960,
+			height: 1080,
+		});
+		expect(webcamBoxSourceSize(camera, null, crop)).toEqual({ width: 960, height: 1080 });
+	});
+
+	it("a template's first PiP sits where the project places camera 1's PiP", () => {
+		const scene = buildSceneDescription(
+			docWith(
+				{
+					cameraTrack: {
+						sourcePath: "/w-1.mp4",
+						startMs: 0,
+						offsetMs: 0,
+						visible: true,
+						width: 1920,
+						height: 1080,
+					},
+					additionalCameraTracks: [{ ...extra, width: 1920, height: 1080 }],
+				},
+				{
+					webcamMaskShape: "rectangle",
+					cameraLayoutRegions: [layoutRegion("screen-pip", [{ camera: 0 }, { camera: 1 }])],
+				},
+			),
+		);
+		const defaultRect = scene.layout.layoutByClip?.[0]?.webcamRect;
+		expect(defaultRect).toBeTruthy();
+		const [first, second] = scene.cameraLayoutRegions?.[0].layers ?? [];
+		// Within a pixel: the default rect is laid out in whole pixels, the PiP's height comes
+		// from the camera's exact 16:9.
+		const { width, height } = scene.output;
+		for (const [key, px] of [
+			["x", width],
+			["y", height],
+			["width", width],
+			["height", height],
+		] as const) {
+			expect(Math.abs(first.rect[key] - (defaultRect?.[key] ?? Number.NaN)) * px).toBeLessThan(1);
+		}
+		expect(second.rect.x + second.rect.width).toBeLessThan(first.rect.x);
+		expect(second.rect.width).toBeCloseTo(first.rect.width, 6);
+	});
+
+	it("an extra camera's PiP is sized from its cropped picture", () => {
+		const scene = buildSceneDescription(
+			docWith(
+				{ additionalCameraTracks: [{ ...extra, width: 1600, height: 900 }] },
+				{
+					webcamMaskShape: "rectangle",
+					cameraSettings: [null, { crop: { x: 0, y: 0, width: 0.5, height: 1 } }],
+					cameraLayoutRegions: [layoutRegion("camera-full-pip", [{ camera: 0 }, { camera: 1 }])],
+				},
+			),
+		);
+		const pip = scene.cameraLayoutRegions?.[0].layers.find((l) => l.camera === 1);
+		const { width, height } = scene.output;
+		// 1600 × 0.5 by 900: the box is 800:900, not the uncropped 16:9.
+		expect(((pip?.rect.width ?? 0) * width) / ((pip?.rect.height ?? 1) * height)).toBeCloseTo(
+			800 / 900,
+			4,
+		);
+	});
+});
diff --git a/src/native/sceneDescription.ts b/src/native/sceneDescription.ts
index 731e61d37..8a5014c5e 100644
--- a/src/native/sceneDescription.ts
+++ b/src/native/sceneDescription.ts
@@ -17,10 +17,14 @@
 
 import type {
 	CameraFullscreenRegion,
+	CameraPerspective,
+	CameraSettings,
+	NormalizedRect,
 	Rotation3DPreset,
 	SpeedRegion,
 	WallpaperMotion,
 	WebcamBackgroundMode,
+	WebcamMaskShape,
 } from "@/components/video-editor/types";
 import { DEFAULT_CROP_REGION, getZoomScale } from "@/components/video-editor/types";
 import { toastText } from "@/i18n/toastText";
@@ -42,9 +46,14 @@ import {
 	readSpeedRegions,
 	resolvePlaybackSegments,
 } from "@/lib/ai-edition/document/timeline";
-import type { AxcutAudioTrack, AxcutClip, AxcutDocument } from "@/lib/ai-edition/schema";
+import type {
+	AxcutAsset,
+	AxcutAudioTrack,
+	AxcutClip,
+	AxcutDocument,
+} from "@/lib/ai-edition/schema";
 import { getEditorSettings } from "@/lib/ai-edition/store/editorSettings";
-import { assetCameraSource } from "@/lib/ai-edition/timeline/camera";
+import { assetAdditionalCameraSources, assetCameraSource } from "@/lib/ai-edition/timeline/camera";
 import { resolveClipSourceEndSec } from "@/lib/ai-edition/timeline/clipDuration";
 import { removedRawSpans } from "@/lib/ai-edition/timeline/programme-time";
 import { takeProgramme } from "@/lib/ai-edition/timeline/take-programme";
@@ -54,17 +63,25 @@ import {
 	MAX_ZOOM_SCALE,
 	maxZoomScaleFor,
 } from "@/lib/ai-edition/timeline/zoom-scale";
+import {
+	fullCameraRowsOfLayoutList,
+	normalizeCameraLayoutRegions,
+	normalizeCameraSettings,
+} from "@/lib/cameraLayouts";
+import { type CameraLayoutContext, resolveCameraLayout } from "@/lib/cameraLayoutTemplates";
 import {
 	normalizeCameraRotation,
 	resolveCameraOrientation,
 	showsDeskLabel,
 } from "@/lib/cameraOrientation";
+import { perspectiveMatrix } from "@/lib/cameraPerspective";
 import {
 	computeCompositeLayout,
 	paddedContentSize,
 	type RenderRect,
 	resolveWebcamLayoutPreset,
 	resolveWebcamReactiveZoom,
+	type WebcamCompositeLayout,
 	webcamSizeToFraction,
 } from "@/lib/compositeLayout";
 import type { CursorKind } from "@/lib/cursor/cursorThemes";
@@ -73,6 +90,7 @@ import { parseCssGradient, resolveLinearGradientAngle } from "@/lib/exporter/gra
 import type { FrameTheme, RecordingFrame, WebcamAnchor } from "@/lib/projectDefaults";
 import { resolveTextFontFamily } from "@/lib/textFonts";
 import { classifyWallpaper } from "@/lib/wallpaper";
+import { clamp01 } from "@/utils/math";
 import type { CompositorClipInput } from "./contracts";
 import { ROUNDNESS_REFERENCE_PX } from "./paramUnits";
 
@@ -145,6 +163,40 @@ export interface SceneCameraFullscreenRegion {
 	fullFrame?: true;
 }
 
+/** Per-camera settings the compositor applies. `index` 0 = camera 1. */
+export interface SceneCamera {
+	index: number;
+	/** 180 only; absent = not turned. Never sent together with `homography`. */
+	rotation?: 180;
+	mirror?: boolean;
+	/** Never sent together with `homography`. */
+	crop?: SceneRect;
+	/** 9 numbers, row-major: target uv -> camera uv. */
+	homography?: number[];
+	/** Width/height of the corrected picture (only with `homography`). */
+	aspect?: number;
+}
+
+/** One camera placed by a layout region, in draw order. */
+export interface SceneCameraLayer {
+	camera: number;
+	rect: SceneRect;
+	radiusFrac: number;
+	shape: string;
+	fillsFrame: boolean;
+}
+
+/** A camera layout (anything but a plain Full Camera) projected onto a clip's source time. */
+export interface SceneCameraLayoutRegion {
+	startSec: number;
+	endSec: number;
+	/** See `SceneZoomRegion.clipIndex`. */
+	clipIndex?: number;
+	/** See `SceneZoomRegion.underTrim`. */
+	underTrim?: boolean;
+	layers: SceneCameraLayer[];
+}
+
 /** A speed region projected onto each clip's source time. The native compositor matches
  *  these against each decoded frame's SOURCE time, the same way zoom regions do — that's
  *  why the spans live in seconds and the underlying projection is `projectRegionsToSourceTime`.
@@ -487,6 +539,10 @@ export interface SceneDescription {
 	 * source-time span after `projectRegionsToSourceTime`). Empty when none set.
 	 */
 	cameraFullscreenRegions: SceneCameraFullscreenRegion[];
+	/** Camera layout regions (several cameras on screen). Omitted when there are none. */
+	cameraLayoutRegions?: SceneCameraLayoutRegion[];
+	/** Settings of the cameras that have any. Omitted when there are none. */
+	cameras?: SceneCamera[];
 	/**
 	 * Speed regions projected onto each clip's source time (one entry per
 	 * source-time span after `projectRegionsToSourceTime`). Empty when none set.
@@ -765,22 +821,135 @@ type Size = { width: number; height: number };
  * That ordering is the fix: the box used to depend on WHO was asking rather than on what
  * was recorded, so a 16:9 camera was framed 16:9 in the preview and 4:3 in the export.
  * The scene and the editor's drag box both read the same answer now.
+ *
+ * A valid `perspective` replaces the crop: the box then takes the corrected picture's own
+ * ratio (`perspective.aspect`), the target format the corners were drawn for.
  */
 export function webcamBoxSourceSize(
 	camera: { width?: number; height?: number } | null | undefined,
 	probed: Size | null,
 	crop: Size,
+	perspective?: CameraPerspective | null,
 ): Size {
 	const source =
 		camera?.width && camera?.height
 			? { width: camera.width, height: camera.height }
 			: (probed ?? { width: 960, height: 720 });
+	if (perspective && perspectiveMatrix(perspective)) {
+		return {
+			width: Math.max(1, Math.round(source.width)),
+			height: Math.max(1, Math.round(source.width / perspective.aspect)),
+		};
+	}
 	return {
 		width: Math.max(1, Math.round(source.width * crop.width)),
 		height: Math.max(1, Math.round(source.height * crop.height)),
 	};
 }
 
+/** Camera 1's stored perspective (`legacyEditor.cameraSettings[0]`), if any. */
+export function camera0PerspectiveOf(
+	document: Pick<AxcutDocument, "legacyEditor"> | null | undefined,
+): CameraPerspective | null {
+	const legacyRaw = document?.legacyEditor as Record<string, unknown> | null | undefined;
+	return normalizeCameraSettings(legacyRaw?.cameraSettings)[0]?.perspective ?? null;
+}
+
+/** Camera 1's PiP box in a clip's resolved layout, in output-frame fractions. */
+export interface ClipPipLayout {
+	webcamRect: NormalizedRect | null;
+	webcamShape: WebcamMaskShape;
+	/** Corner radius as a fraction of the box's short side; null without a box. */
+	webcamRadiusFrac: number | null;
+}
+
+/**
+ * Camera 1's box of a `computeCompositeLayout` result (in `frame` pixels) as frame fractions,
+ * with its shape and radius. The scene ships these per clip; the editor anchors its layout
+ * hitboxes on the same values.
+ */
+export function clipPipLayoutOf(
+	layout: Pick<WebcamCompositeLayout, "webcamRect"> | null | undefined,
+	frame: Size,
+	fallbackShape: WebcamMaskShape,
+): ClipPipLayout {
+	const box = layout?.webcamRect ?? null;
+	if (!box) return { webcamRect: null, webcamShape: fallbackShape, webcamRadiusFrac: null };
+	const shortSide = Math.min(box.width, box.height);
+	return {
+		webcamRect: {
+			x: box.x / frame.width,
+			y: box.y / frame.height,
+			width: box.width / frame.width,
+			height: box.height / frame.height,
+		},
+		webcamShape: box.maskShape ?? fallbackShape,
+		webcamRadiusFrac:
+			shortSide > 0 && box.borderRadius != null ? box.borderRadius / shortSide : null,
+	};
+}
+
+/**
+ * What `resolveCameraLayout` needs to place a layout section's cameras, from the asset the
+ * section is anchored to. The scene and the editor's drag hitboxes both build it here, so
+ * the boxes the editor offers are the ones the compositor draws.
+ */
+export function cameraLayoutContextOf(input: {
+	/** Output frame (only its proportions matter). */
+	frame: Size;
+	asset: AxcutAsset;
+	cameraSettings: readonly (CameraSettings | null | undefined)[];
+	/** Camera 1's crop (`settings.webcamCropRegion`). */
+	webcamCropRegion: Size;
+	/** Camera 1's probed size, for a document whose camera has no stored dimensions. */
+	probedCamera0Size: Size | null;
+	/** The clip's resolved camera-1 layout, if it has one. */
+	clipLayout: ClipPipLayout | null | undefined;
+	webcamMaskShape: WebcamMaskShape;
+	webcamRoundness: number;
+	/** The clip lays out as picture-in-picture (a block preset's camera box is no PiP). */
+	pipPreset: boolean;
+}): CameraLayoutContext {
+	const { asset, cameraSettings, clipLayout } = input;
+	// The size of the picture each camera's box shows: after its crop, like the
+	// camera-1 box `webcamSourceSizeOf` lays out (a perspective replaces the crop).
+	const croppedSize = (camera: number): Size => {
+		if (camera === 0) {
+			return webcamBoxSourceSize(
+				asset.cameraTrack,
+				input.probedCamera0Size,
+				input.webcamCropRegion,
+				cameraSettings[0]?.perspective,
+			);
+		}
+		const track = asset.additionalCameraTracks?.[camera - 1];
+		const size =
+			track?.width && track?.height
+				? { width: track.width, height: track.height }
+				: { width: 16, height: 9 };
+		const crop = cameraSettings[camera]?.crop;
+		return crop ? { width: size.width * crop.width, height: size.height * crop.height } : size;
+	};
+	const cameraAspect = (camera: number) => {
+		const perspective = cameraSettings[camera]?.perspective;
+		if (perspective && perspectiveMatrix(perspective)) return perspective.aspect;
+		const size = croppedSize(camera);
+		return size.width / size.height;
+	};
+	return {
+		frame: input.frame,
+		cameraAspect,
+		pipShape: clipLayout?.webcamShape ?? input.webcamMaskShape,
+		// A clip without a camera-1 box (no-webcam preset, no camera 1) still rounds its
+		// PiPs the way `computeCompositeLayout` would: the radius is a fraction
+		// of the short side (= roundness of half of it).
+		pipRadiusFrac: clipLayout?.webcamRadiusFrac ?? clamp01(input.webcamRoundness) / 2,
+		// The template PiPs start where the project puts camera 1's PiP — only in the
+		// picture-in-picture preset; a block preset's camera box is no PiP to anchor on.
+		defaultPipRect: input.pipPreset ? clipLayout?.webcamRect : null,
+	};
+}
+
 const DESK_LABEL_KEY = "cameraFullscreen.deskLabel";
 
 /** The translated label, or "" when the locale has no such key (`translate` echoes the key). */
@@ -1008,6 +1177,7 @@ export function buildSceneDescription(
 		const asset = assetById.get(clip.assetId);
 		if (!asset?.originalPath) return [];
 		const camera = assetCameraSource(asset);
+		const additionalCameras = assetAdditionalCameraSources(asset);
 		// ponytail: `asset.audio` exists in the schema but the probe pipeline never
 		// populates it, so there is no per-asset "is there a track?" signal to read
 		// yet. Every consumer downstream degrades on a stream-less file (audio.rs
@@ -1023,6 +1193,7 @@ export function buildSceneDescription(
 				sourceEndSec: resolveClipSourceEndSec(clip, asset),
 				webcamOffsetSec: camera.offsetSec,
 				hasAudio: true,
+				...(additionalCameras.length > 0 ? { additionalCameras } : {}),
 				// A held segment has an empty source window and exists only for the frames it
 				// holds; every other clip holds nothing.
 			},
@@ -1099,16 +1270,40 @@ export function buildSceneDescription(
 		captionSettings,
 		captionAspect,
 	);
+	const legacyRaw = document.legacyEditor as Record<string, unknown> | null;
+	const layoutRegions = normalizeCameraLayoutRegions(legacyRaw?.cameraLayoutRegions);
+	const cameraSettings = normalizeCameraSettings(legacyRaw?.cameraSettings);
+	// Two disjoint lists: camera 1's Full Camera sections live in `cameraFullscreenRegions`
+	// (they keep the desk view and its label), every other layout in `cameraLayoutRegions`.
+	// Both are clip-anchored, so `projectRegionsToSource` takes its anchored branch for both.
+	const fullscreenRegions =
+		(legacyRaw?.cameraFullscreenRegions as CameraFullscreenRegion[] | undefined) ?? [];
+	// A hand-written layout list may still carry a camera-1 camera-full row. It becomes a Full
+	// Camera region unless one already covers its span, so the same section is never emitted
+	// twice (two covers, two desk labels).
+	const handWrittenFullCamera = fullCameraRowsOfLayoutList(legacyRaw?.cameraLayoutRegions)
+		.filter(
+			(row) =>
+				!fullscreenRegions.some(
+					(region) => region.startMs <= row.startMs && region.endMs >= row.endMs,
+				),
+		)
+		.map(({ template: _template, slots: _slots, ...region }): CameraFullscreenRegion => region);
 	const projectedCameraFullscreenRegions = projectRegionsToSource(
-		(
-			((document.legacyEditor as Record<string, unknown> | null)?.cameraFullscreenRegions as
-				| CameraFullscreenRegion[]
-				| undefined) ?? []
-		).map((region) => ({ ...region, sectionId: region.id })),
+		[...fullscreenRegions, ...handWrittenFullCamera].map((region) => ({
+			...region,
+			sectionId: region.id,
+		})),
 		visibleClips,
 		document.timeline.clips,
 		() => createId("camfull"),
 	);
+	const projectedLayoutRegions = projectRegionsToSource(
+		layoutRegions,
+		visibleClips,
+		document.timeline.clips,
+		() => createId("camlay"),
+	);
 	const projectedAnnotations = projectRegionsToSource(
 		[
 			...(document.annotations ?? []),
@@ -1210,6 +1405,7 @@ export function buildSceneDescription(
 			assetById.get(clip.assetId)?.cameraTrack,
 			webcamSourceSize,
 			settings.webcamCropRegion,
+			cameraSettings[0]?.perspective,
 		);
 	const layoutForClip = (
 		screenSize: { width: number; height: number },
@@ -1245,17 +1441,18 @@ export function buildSceneDescription(
 		const shortSide = box ? Math.min(box.width, box.height) : 0;
 		return box && shortSide > 0 && radius != null ? radius / shortSide : null;
 	};
-	const resolvedLayoutOf = (layout: ReturnType<typeof layoutForClip>) =>
-		layout
-			? {
-					screenRect: toFrameFractions(layout.screenRect),
-					webcamRect: layout.webcamRect ? toFrameFractions(layout.webcamRect) : null,
-					screenRadiusFrac: radiusFractionOf(layout.screenRect, layout.screenBorderRadius),
-					webcamRadiusFrac: radiusFractionOf(layout.webcamRect, layout.webcamRect?.borderRadius),
-					webcamShape: layout.webcamRect?.maskShape ?? settings.webcamMaskShape,
-					screenCover: formatFill || (layout.screenCover ?? false),
-				}
-			: null;
+	const resolvedLayoutOf = (layout: ReturnType<typeof layoutForClip>) => {
+		if (!layout) return null;
+		const pip = clipPipLayoutOf(layout, outputDims, settings.webcamMaskShape);
+		return {
+			screenRect: toFrameFractions(layout.screenRect),
+			webcamRect: pip.webcamRect,
+			screenRadiusFrac: radiusFractionOf(layout.screenRect, layout.screenBorderRadius),
+			webcamRadiusFrac: pip.webcamRadiusFrac,
+			webcamShape: pip.webcamShape,
+			screenCover: formatFill || (layout.screenCover ?? false),
+		};
+	};
 	// One resolved layout per visible clip, index-aligned with `clips` / `cropByClip`.
 	// `for_clip_window` (Rust) selects the entry for the clip being composed, so the
 	// draw path keeps reading a single `layout` and needs no per-clip branch of its own.
@@ -1286,6 +1483,61 @@ export function buildSceneDescription(
 		),
 	);
 
+	// Camera layout regions: each projected piece gets its layers resolved against its own clip's
+	// asset, since which cameras exist (and how big they are) is per asset.
+	const sceneCameraLayoutRegions = projectedLayoutRegions.flatMap(
+		(region): SceneCameraLayoutRegion[] => {
+			if (region.clipIndex === undefined) return [];
+			const asset = assetById.get(visibleClips[region.clipIndex]?.assetId ?? "");
+			if (!asset) return [];
+			const sources = [assetCameraSource(asset), ...assetAdditionalCameraSources(asset)];
+			const clip = visibleClips[region.clipIndex];
+			const pipPreset =
+				clip !== undefined &&
+				resolveWebcamLayoutPreset(settings.webcamLayoutPreset, clipHasCamera(clip)) ===
+					"picture-in-picture";
+			const ctx = cameraLayoutContextOf({
+				frame: outputDims,
+				asset,
+				cameraSettings,
+				webcamCropRegion: settings.webcamCropRegion,
+				probedCamera0Size: webcamSourceSize,
+				clipLayout: layoutByClip[region.clipIndex],
+				webcamMaskShape: settings.webcamMaskShape,
+				webcamRoundness: settings.webcamRoundness,
+				pipPreset,
+			});
+			const layers = resolveCameraLayout(region, ctx).filter(
+				(layer) => (sources[layer.camera]?.path ?? "") !== "",
+			);
+			if (layers.length === 0) return [];
+			return [
+				{
+					startSec: region.startMs / 1000,
+					endSec: region.endMs / 1000,
+					clipIndex: region.clipIndex,
+					...(region.underTrim ? { underTrim: true } : {}),
+					layers,
+				},
+			];
+		},
+	);
+	const sceneCameras = cameraSettings.flatMap((camera, index): SceneCamera[] => {
+		if (!camera) return [];
+		const homography = camera.perspective ? perspectiveMatrix(camera.perspective) : null;
+		if (homography && camera.perspective) {
+			// A perspective already defines the upright, unmirrored picture and replaces the crop.
+			return [{ index, homography, aspect: camera.perspective.aspect }];
+		}
+		return [
+			{
+				index,
+				...(camera.rotation === 180 ? { rotation: 180 as const } : {}),
+				...(camera.mirror !== undefined ? { mirror: camera.mirror } : {}),
+				...(camera.crop ? { crop: { ...camera.crop } } : {}),
+			},
+		];
+	});
 	return {
 		clips,
 		layout: {
@@ -1523,6 +1775,10 @@ export function buildSceneDescription(
 		// shipped inert — `speed_at` (regions.rs) matches on clipIndex + time with no window
 		// to bound it, and the export's frame count is derived from these spans. Nothing to
 		// gain, an arithmetic to put at risk.
+		...(sceneCameraLayoutRegions.length > 0
+			? { cameraLayoutRegions: sceneCameraLayoutRegions }
+			: {}),
+		...(sceneCameras.length > 0 ? { cameras: sceneCameras } : {}),
 		speedRegions: projectedSpeedRegions
 			.filter((region) => !region.underTrim)
 			.map((region) => ({
diff --git a/src/types/js-aruco2.d.ts b/src/types/js-aruco2.d.ts
new file mode 100644
index 000000000..f0531e716
--- /dev/null
+++ b/src/types/js-aruco2.d.ts
@@ -0,0 +1,53 @@
+// Minimal declarations for js-aruco2 2.0.0, which ships no types. Only what this app uses.
+// The package is CommonJS: `src/aruco.js` assigns `this.AR`, so the default import is
+// `{ AR }`; each dictionary file registers itself in `AR.DICTIONARIES` as a side effect.
+
+declare module "js-aruco2" {
+	export interface ArucoPoint {
+		x: number;
+		y: number;
+	}
+
+	export interface ArucoMarker {
+		id: number;
+		/** Four corners, clockwise from the marker's own top-left. */
+		corners: ArucoPoint[];
+		hammingDistance: number;
+	}
+
+	export interface ArucoDictionaryDefinition {
+		nBits: number;
+		/** Minimum distance between codes; null lets the library compute it. */
+		tau: number | null;
+		/** Codes as numbers, hex strings or byte arrays (row-major bits). */
+		codeList: Array<number | string | number[]>;
+	}
+
+	export interface ArucoDictionary {
+		/** Each code as a string of `nBits` "0"/"1", row-major. */
+		codeList: string[];
+		nBits: number;
+		/** Side in cells including the black border (4x4 → 6). */
+		markSize: number;
+		tau: number;
+		generateSVG(id: number): string;
+	}
+
+	export interface ArucoDetector {
+		detectImage(width: number, height: number, data: ArrayLike<number>): ArucoMarker[];
+	}
+
+	export interface ArucoNamespace {
+		DICTIONARIES: Record<string, ArucoDictionaryDefinition>;
+		Dictionary: new (name: string) => ArucoDictionary;
+		Detector: new (config?: {
+			dictionaryName?: string;
+			maxHammingDistance?: number;
+		}) => ArucoDetector;
+	}
+
+	const aruco: { AR: ArucoNamespace };
+	export default aruco;
+}
+
+declare module "js-aruco2/src/dictionaries/aruco_4x4_1000.js" {}
diff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.md
index 4f673be37..712405f1d 100644
--- a/technical-documentation/testing/manual-e2e-checklist.md
+++ b/technical-documentation/testing/manual-e2e-checklist.md
@@ -235,6 +235,28 @@ Up to four cameras record into one take on the native Windows path: camera 1 as
 - [ ] With the first camera turned off in the HUD, record again and confirm no additional camera is recorded (additional cameras follow camera 1).
 - [ ] Probe every file: `ffprobe -show_entries format=duration` of each camera file is within 0.2 s of the screen file's.
 
+### Several cameras in the picture
+
+Camera layout regions put up to four cameras in the picture at once (`screen-pip`, `camera-full`, `camera-full-pip`, `side-by-side`), glide between adjacent regions, and a camera with a perspective correction is drawn rectified. The synthetic half is scripted: `node scripts/multicam-fixture.mjs generate <dir>`, then `export <dir>/multicam.openscreen <out.mp4>` from a built tree with the addon loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE`, then `check <out.mp4>` prints a pass/fail table (template rects ±2 px, the glide across 3 s frame by frame, the halves of side-by-side, a rectified checkerboard with square, equally spaced fields). `persp.openscreen` (`check <out.mp4> persp`) gives camera 1 a 4:3 perspective, in its default PiP and in a Full Camera section; `seam.openscreen` (`check <out.mp4> seam`) puts a camera-1 Full Camera section right before a `camera-full-pip` region, and camera 1 must glide straight from the frame into its PiP slot. Run it after any change to the camera planner, the layer shaders or the extra-camera decoding. The checks below are the part it cannot reach: real cameras, the preview, and the live loop.
+
+- [ ] Layouts with real cameras. On a take with three cameras, add a `camera-full-pip` region with the desk camera full and the face camera as the PiP, a `screen-pip` region with two PiPs, and a `side-by-side` region. In the preview and in an MP4 1080p export each camera sits where its template puts it, upright, unmirrored unless set, and not stretched.
+- [ ] Glide. Place two regions back to back. Across the boundary every camera that is in both moves from its old place to its new one in about 0.4 s and never disappears for a frame; a camera only in one of them fades. Step frame by frame with the arrow keys across the boundary, then confirm the same in the export (`ffmpeg -ss <t> -i <export> -frames:v 1 frame.png` every 1/30 s).
+- [ ] Perspective with an A4 sheet. Point a static camera obliquely at an A4 sheet, set its perspective to the sheet's four corners with the A4 aspect (297/210 landscape), and show it in a `camera-full` region and in a PiP. The sheet reads upright with right-angled corners in both, in a `side-by-side` half too (cropped there, never squashed), and the text on it is not distorted.
+- [ ] Export against preview. Pause on a frame inside each region and compare the preview with the same frame of the export: the same cameras in the same places.
+- [ ] Performance with three cameras. Play a project where three cameras are visible together and watch for stutter; then export it and the same take with its layout regions removed, and log both export times (target: at most 2x).
+
+### Several cameras in the editor
+
+The editing half of camera layouts: the *Add layout* menu on the timeline toolbar, the inspector of a layout section (template, a camera per place, *Reset windows*), dragging and resizing a PiP window in the preview, the *Cameras* list under *Camera layout* and its calibration dialog (crop, *Correct perspective…*, *Detect markers*, *Print marker sheet*). The in-app loop on an existing two-camera project is scripted: `node scripts/editor-multicam-smoke.mjs --source <projectId> --out <dir>` (header has the build steps). It works on a copy of the project, asserts the saved document after every step and captures the preview inside each section, but it drives Playwright's synthetic input and never touches a camera. The checks below need real cameras and a real hand on the mouse.
+
+- [ ] Desk camera full, face as PiP. Record a take with a desk camera and a face camera, add a *Camera + inset* section, put the desk camera in place 1 and the face camera in place 2 in the inspector. The preview shows both inside the section, in the places the inspector names, and moves straight back to the clip's layout after it.
+- [ ] Screen + two PiPs. With three cameras, add a *Screen + camera* section and give it two PiP cameras. Drag each window to a corner of your choice and resize one by its corner handle; a round or square window stays square. *Reset windows* puts them back, and Ctrl+Z after each drag undoes exactly that drag.
+- [ ] Side by side. Add a *Side by side* section with two cameras and swap them in the inspector. Each half shows its camera cropped, never squashed.
+- [ ] Full Camera and layouts share one lane. Press **C** inside an existing layout section: the "cannot place" notice appears and nothing is added. Convert a Full Camera section to *Screen + camera* in its inspector and back; undo and redo each step.
+- [ ] Perspective with the printed marker sheet. *Print marker sheet* from the calibration dialog (print at 100 %, no scaling), lay it flat in front of the desk camera, record a few seconds, open *Correct perspective…* for that camera and press *Detect markers*: all four corners land on the markers' outer corners. Apply with *A4 landscape*: in a full place the sheet reads upright with right angles. Repeat with a plain A4 sheet and the corners placed by hand (drag, then the arrow keys with the magnifier).
+- [ ] Export against preview. Export MP4 1080p and compare a frame inside each section with the paused preview at the same time: the same cameras in the same places, the same windows after a drag, the same perspective. Use `ffmpeg -ss <t> -i <export> -frames:v 1 frame.png`, not the downscaled preview, for any pixel question.
+- [ ] Reopen. Save, quit, start again: every section, its cameras, the dragged windows and the perspective come back as they were.
+
 ## Editor opens and loads the project
 
 - [ ] Confirm the editor opens after a successful stop, in Edit mode, with the expected project title and asset and a "Recording added to a new project" toast.
@@ -879,3 +901,8 @@ On macOS 15.2+ it opens at launch, until it has been closed once, while one of i
 | 2026-10-04 | dev `feat/multi-camera-recording` at `212c07f7` (feature head `23ea0751` + the HUD probe lint fix); `wgc-capture.exe` rebuilt from this tree by `npm run build:native:win` | Windows 11 on ARM64 (Snapdragon X Elite), one built-in camera (`AI Front Camera`), driven without computer-use | **Partial — the two-webcam run on site is outstanding; sub-project not complete until logged** | **Ran:** unit suite (`npm run test`, 304 of 305 files, the one failure `LeftPanel.copyMessage.test.tsx` passed alone, a load flake), both `tsc`, lint (0 errors, 26 warnings, the base count), `i18n:check`; the helper's native unit tests (`node scripts/build-windows-wgc-helper.mjs`, all pass); helper smoke runs `npm run test:wgc-helper:win`, `-- --webcam` and `-- --webcam --missing-second-webcam` (index 1 dropped and named, camera 1 kept); a direct helper run listing the one camera twice: camera 1 recorded, camera 2 dropped with `webcam-unavailable` index 1 and "already recording in this take", `webcamPaths` held one file, exit 0, camera file 4.81 s against the screen's 4.80 s. **Not run:** the app click-through (HUD *Additional cameras*, editor, save and reopen, the session manifest's `additionalWebcams`, the "Not recorded" notice): no computer-use here and only one camera. **Not covered at all:** two real cameras recording together, identical-name Brios, 1080p and 4K load, clap sync, macOS and Linux. |
 | 2026-10-05 | dev `feat/multi-camera-recording` at `86d49475`; `wgc-capture.exe` from `electron/native/wgc-capture/build` (4 Oct 13:05, `findstr` hit the fix-wave string *Could not remove the dropped camera file* and the control `encoder-selection`); `compositor_view.node` built from this tree by `npm run build:native:compositor` (ARM64) and loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE` next to the vendored win32-arm64 ffmpeg | Windows 11 on ARM64 (Snapdragon X Elite), **Logitech BRIO** (USB) + built-in `AI Front Camera`, 2560×1440 display | **Partial — two real cameras pass; Brio + C920, two identical Brios, 4K load and a mid-take camera loss not run yet** | *Helper:* Brio as camera 1 + built-in as camera 2 at 1080p30, 38 s take with three claps — both camera files 1146 frames / 38.19 s, screen 38.20 s at a steady 30 fps (`[pacing] frames=1146 elapsed_ms=38201`), camera 2 skipped the claimed Brio (`already recording in this take`), `webcamPaths` listed both. Clap sync by per-frame motion cross-correlation: 0 frames over the whole take, ≤ 1 frame (33 ms) per 3 s window; an 8-frame strip of the strongest clap shows the hands meeting and opening in the same frames on both. *App (HUD driven by the user):* Brio as camera 1, built-in ticked under *Additional cameras* — three files written, session `additionalWebcams` with label `AI Front Camera`, no *Not recorded* notice; Studio shows screen + camera 1 as before; the project holds `additionalCameraTracks` (1920×1080, offset 0, label) and keeps it after reopen, an edit and save. | The editor cannot select camera 2 yet — by design, sub-projects 2/3. First dev launch had no `compositor_view.node` in the worktree (blank Studio: `native addon not present`) — environment, not product. |
 | 2026-10-05 | dev `feat/multi-camera-recording` at `e0067391` (`fix(wgc): stop and report a camera that is unplugged mid-take`); `wgc-capture.exe` rebuilt by `npm run build:native:win`, `findstr` hit *Webcam lost during the take* and the control `encoder-selection` in `build` and `binwin32-x64` | Windows 11 on ARM64 (Snapdragon X Elite), **two Logitech BRIO** (identical names, USB instances `C&1EF69AFB` and `9&299A5C35`), **HD Pro Webcam C920**, built-in `AI Front Camera`; helper-level runs with a `webcams` list | **Partial — every on-site case passes at 1080p; 4K with a second camera paces cameras at 27.8 fps; the unplug notice was checked at helper level, not in the app UI** | *Brio + C920, 1080p:* 310/310/310 frames (camera 1, camera 2, screen). *Two identical Brios:* camera 2 skipped the claimed Brio (`already recording in this take`) and opened the other one — two different pictures; which Brio became camera 1 followed enumeration order, not intent (known limitation). *All four cameras at once, 1080p:* four different pictures, 392 frames each, screen 392 at a steady 30 fps. *4K:* one Brio alone 3840×2160 at 30 fps (401/401); two Brios requested at 4K → the Brio on a cheap USB cable only offers 1080p even alone (USB 2 link — hardware), and with 4K + 1080p both cameras paced at **27.8 fps** (363 frames in 13.07 s), screen 29.5 fps — all cameras are converted and encoded on the screen writer thread; follow-up: a worker thread per camera. *Unplug the C920 mid-take:* before the fix the C920 file ran on with a frozen picture and was still listed (`readFailures=737 lastReadHr=0xc00d3ea2`); after `e0067391` the helper logs `Webcam lost during the take: HD Pro Webcam C920 hr=0xc00d3ea2`, the C920 file ends at the loss (200 frames / 6.66 s), the Brio and screen run the full 27.7 s, and `webcamPaths` lists only the Brio — the input Electron turns into *Stopped early: …*. | The *Stopped early* toast itself was not watched in the app; it is unit-tested (`labelsOfWebcamsStoppedEarly`, renderer stop test). |
+| 2026-10-05 | dev `feat/multi-camera-layouts` at `1c8bfb17` + the fixture script of this entry's commit; `compositor_view.node` (ARM64) built from this tree by `npm run build:native:compositor`, loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE` with the vendored ARM64 ffmpeg DLLs on `PATH`; renderer from `npm run build-vite` | Windows 11 on ARM64 (Snapdragon X Elite), h264_mf export, no computer-use | **Partial — synthetic export passes; the real-device run with the user's cameras is outstanding** | *Several cameras in the picture, scripted half* (`scripts/multicam-fixture.mjs`): 8 s 1920×1080 screen, red / green / perspective-checkerboard cameras at 1280×720, regions `screen-pip [0,1]` 1–3 s, `camera-full-pip [1,0]` 3–5 s, `side-by-side [0,1]` 5.5–7 s, `camera-full [2]` 7–8 s; export 1752×1080 (the project's default Auto format) at 60 fps. **17/17 checks pass:** PiPs at the template rects (max 1.24 px), green full frame at 4 s, the 3 s glide on the planned rect in all 22 frames (max 0.48 px, never without green, never shrinking), side-by-side halves exact at 6.5 s (0 px) and the 6.0 s lead-in on its planned rect (0.14 px), checkerboard at 7.5 s with 119.96 × 120.03 px fields on the cover-fitted grid (max 1.12 px). **Defect found and fixed** (`1c8bfb17`): a perspective-corrected camera was stretched into any box of another ratio (fields measured 109.5 × 120 px before). Export render time (first progress line to *Exported*, three runs each): one camera 2.39 / 2.21 / 2.79 s, three cameras 2.84 / 2.84 / 2.79 s, about 1.15x. **Not run:** the real cameras, the A4 sheet, the preview (no computer-use: preview against export and the live-loop pacing with 1 vs 3 cameras unmeasured), macOS (Metal) and Linux. |
+| 2026-10-05 | dev `feat/multi-camera-layouts` at the final-review fix commits (`cd85d203`..`46b1b56e`) + the fixture script of this entry's commit; `compositor_view.node` (ARM64) built from this tree by `npm run build:native:compositor`, loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE` with the vendored ARM64 ffmpeg DLLs on `PATH`; renderer from `npm run build-vite` | Windows 11 on ARM64 (Snapdragon X Elite), h264_mf export, no computer-use | **Partial — synthetic export passes; the real-device run with the user's cameras is outstanding** | *Several cameras in the picture, scripted half*, re-run after the final review's fixes (camera-1 perspective, Full Camera next to a layout region, template PiPs on the project's PiP). multicam **17/17** (template PiPs now anchored on camera 1's default PiP, max 1.00 px; 3 s glide max 1.16 px; checkerboard 119.96 × 120.03 px, grid 1.12 px). persp **5/5**: camera 1's default PiP is 4:3 ([1298, 734, 1730, 1058]) with 36.03 × 36.00 px fields; in Full Camera the 4:3 picture is cover-fitted with 146.00 × 145.99 px fields, grid error 1.22 px. seam **7/7**: camera 1 fills the frame up to the seam at 3 s (0 px), then glides on the planned rect (max 1.39 px), never growing back, and the first frame after the seam is still 1618 px wide (not the default PiP); camera 2 fills the frame under it at 4.6 s. One camera: only the red default PiP [1298, 815/816, 1730, 1058] at 0.5, 4.0 and 7.5 s. **Not run:** the real cameras, the preview (no computer-use), macOS (Metal) and Linux. |
+| 2026-10-05 | dev `feat/multi-camera-layouts` at `ce00b741`; `npm run build-vite`; `compositor_view.node` (ARM64) built from this tree and loaded via `OPENSCREEN_COMPOSITOR_VIEW_NODE` next to the vendored win32-arm64 ffmpeg DLLs | Windows 11 on ARM64 (Snapdragon X Elite) | **Partial — Studio preview smoke via Playwright (Electron, real user data); no layout regions in the projects used** | Driven by a Playwright `_electron` script against the built app with the real `%APPDATA%openscreen` (projects folder backed up and restored byte-identical afterwards). Two existing projects opened by the editor's auto-load: (1) today's two-camera recording (Brio + built-in; camera 1 drawn as PiP, camera 2 stored but not shown — expected before sub-project 3), (2) an older one-camera project in the dual-frame layout. Both: preview shows screen + camera, the picture changes across open → play → step, `Space` plays (t 0.74 → 2.56 s / 0 → 6.3 s), `ArrowRight` steps the playhead, no console errors in the editor. | Not covered: scrubbing by dragging the playhead, clip switching (single-clip projects), a project with layout regions in the live preview, preview frame pacing, HUD (Playwright cannot reach the click-through HUD). |
+| 2026-10-05 | dev `feat/multi-camera-layouts` at `8524ac0c` (+ the smoke script of this entry's commit); `npm run build-vite`; `compositor_view.node` (ARM64, SHA256 `3e2ce0f0…3845cc1f`) built from this tree by `npm run build:native:compositor` and loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE` next to the vendored win32-arm64 ffmpeg DLLs | Windows 11 on ARM64 (Snapdragon X Elite), driven by Playwright (`_electron`), no computer-use, no camera | **Partial — scripted editor pass passed (23/23 checks); the real-camera run by the user is outstanding; 1 finding** | **Several cameras in the editor, scripted half only:** `node scripts/editor-multicam-smoke.mjs` on a copy of a recorded two-camera project (Logitech Brio + `AI Front Camera`; the user's projects folder backed up first and hash-verified byte-identical afterwards). Added a *Camera + inset* section from the layout menu, swapped its cameras twice in the inspector, added a Full Camera section with **C**, converted it to *Screen + camera* and back, Ctrl+Z / Ctrl+Shift+Z, dragged the inset window in the preview, ran *Detect markers* (no markers in the shot: the "not all four" message, cleared by the next corner move), moved corners by keys and by mouse, applied an A4-landscape perspective to camera 2, saved, relaunched: the saved file matched after every step and after the reopen, no console errors. First in-app run of the live preview for layout sections: camera-full-pip, screen-pip with two windows and the rectified camera 2 all render in the preview. **Finding (not fixed):** with camera 1 in the large place of a `camera-full-pip` section a strip of wallpaper shows along the left edge (≈0.5 % of the width) and the top row of the preview; camera 2 in the same place and camera 1 in a Full Camera section fill the frame. Camera 1 there carries `webcamCropRegion` and `webcamCropPan`; to be measured on an export frame. *Explained in the next row: not a defect, the capture fell in the section's lead-in glide.* **Not covered:** real cameras, real OS input, the printed sheet, side by side, resize handle, export against preview, every item of the section above. |
+| 2026-10-05 | dev `feat/multi-camera-layouts` at `ec1c7284` (+ the smoke-script change of this entry's commit); `npm run build-vite`; `compositor_view.node` (ARM64) unchanged from the previous row (no crate changed since), loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE` next to the vendored win32-arm64 ffmpeg DLLs | Windows 11 on ARM64 (Snapdragon X Elite), driven by Playwright (`_electron`), no computer-use, no camera | **Partial — scripted editor pass passed (27/27 checks), no defect; the real-camera run by the user is still outstanding** | **Re-run of the scripted half after the final-review fixes, with the steady-state capture corrected.** The previous row's wallpaper strip was the section's designed lead-in glide: its section (3.00–4.73 s) overlapped the project's 0–3.44 s trim, so its visible span was 3.44–4.73 s and the capture at 3.87 s, the middle of the stored span, fell at 99.3 % of the lead-in. The script now places its section clear of the project's trims (5.00–6.73 s here) and captures at the middle of the visible, trim-aware span (5.864 s). It also measures the composed frame against a plain frame at 12 s, pixel by pixel along the four outermost left columns and top rows: with camera 1 in the large place the wallpaper share is 0 in columns 1–3 and rows 0–3 (mean colours 231–239, the camera's wall, against the wallpaper's 89,65,101 and 220,162,155 at the same pixels), so camera 1 fills the frame edge to edge; camera 2 likewise (≤ 0.03). Column 0 is the same grey (185,188,192) in every capture including the plain frame, a resampling seam of the 428 css px canvas at 125 %, and is skipped. The same measure on the previous row's capture shows the strip in columns 1–2. Everything else as in the previous row: layout menu, camera swap, **C**, template conversion, undo and redo, PiP drag, calibration dialog with *Detect markers*, perspective apply, save and reopen, no console errors. The user's projects folder was backed up and hash-verified byte-identical afterwards, with no extra files. **Not covered:** as in the previous row (real cameras, real OS input, the printed sheet, side by side, resize handle, export against preview). |