Eyevinn
diff --git a/‎backend/src/api/flows.rs‎
Lines changed: 57 additions & 0 deletions b/‎backend/src/api/flows.rs‎
Lines changed: 57 additions & 0 deletions
diff --git a/‎backend/src/blocks/builtin/vision_mixer/builder/mod.rs‎
Lines changed: 2 additions & 0 deletions b/‎backend/src/blocks/builtin/vision_mixer/builder/mod.rs‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎backend/src/blocks/builtin/vision_mixer/builder/pad_layout.rs‎
Lines changed: 57 additions & 2 deletions b/‎backend/src/blocks/builtin/vision_mixer/builder/pad_layout.rs‎
Lines changed: 57 additions & 2 deletions
diff --git a/‎backend/src/blocks/builtin/vision_mixer/builder/pipeline_cpu.rs‎
Lines changed: 89 additions & 1 deletion b/‎backend/src/blocks/builtin/vision_mixer/builder/pipeline_cpu.rs‎
Lines changed: 89 additions & 1 deletion
@@ -1704,6 +1704,63 @@ pub async fn select_preview(
     }))
 }
 
+/// Get the current composition of a single PiP on a vision mixer block.
+///
+/// Returns the same per-PiP state as the corresponding entry in
+/// `VisionMixerState::pips`. Useful for exporting one PiP's composition
+/// (e.g. to save it as a reusable layout preset); restore it with a `PUT`
+/// to the same path.
+#[utoipa::path(
+    get,
+    path = "/api/flows/{flow_id}/blocks/{block_id}/pip/{pip_idx}",
+    tag = "flows",
+    params(
+        ("flow_id" = String, Path, description = "Flow ID (UUID)"),
+        ("block_id" = String, Path, description = "Vision mixer block instance ID"),
+        ("pip_idx" = usize, Path, description = "PiP index (0-based)")
+    ),
+    responses(
+        (status = 200, description = "Current PiP composition", body = strom_types::api::PipState),
+        (status = 404, description = "Block has no live state (pipeline not running) or PiP index out of range", body = ErrorResponse),
+    )
+)]
+pub async fn get_pip_config(
+    Path((flow_id, block_id, pip_idx)): Path<(FlowId, String, usize)>,
+) -> Result<Json<strom_types::api::PipState>, (StatusCode, Json<ErrorResponse>)> {
+    let overlay = crate::blocks::builtin::vision_mixer::overlay::get_overlay_state(&block_id)
+        .ok_or_else(|| {
+            (
+                StatusCode::NOT_FOUND,
+                Json(ErrorResponse::with_details(
+                    "Vision mixer state not available",
+                    format!(
+                        "No live overlay state for block {} in flow {} (pipeline not running)",
+                        block_id, flow_id
+                    ),
+                )),
+            )
+        })?;
+
+    if pip_idx >= overlay.num_pips {
+        return Err((
+            StatusCode::NOT_FOUND,
+            Json(ErrorResponse::with_details(
+                "PiP index out of range",
+                format!(
+                    "PiP index {} out of range (block {} has {} PiPs)",
+                    pip_idx, block_id, overlay.num_pips
+                ),
+            )),
+        ));
+    }
+
+    Ok(Json(strom_types::api::PipState {
+        bg: overlay.pip_bg_input(pip_idx),
+        zones: overlay.pip_zones(pip_idx),
+        transforms: overlay.pip_transforms(pip_idx),
+    }))
+}
+
 /// Update a PiP composition (background + overlay inputs) on a vision mixer block.
 ///
 /// The change is applied live to all places where the PiP is currently visible:
 
@@ -328,6 +328,8 @@ pub(super) fn setup_overlay_renderer(
         initial_pvw_input,
         p.labels.to_vec(),
         mv_layout.clone(),
+        p.pgm_w,
+        p.pgm_h,
         p.show_vu_meters,
         pip_initial,
     ));
 
@@ -51,13 +51,30 @@ fn initial_pad_geom_for_input(
             l.w,
             l.h,
             1.0,
-            (overlay_zorder + l.zorder_offset) as u64,
+            vision_mixer::zone_content_zorder(overlay_zorder, l.zorder_offset) as u64,
         )
     } else {
         (0, 0, 1, 1, 0.0, bg_zorder as u64)
     }
 }
 
+/// Initial properties for a border underlay pad: hidden, explicit geometry.
+/// Zones (and thus borders) are runtime-only, so every underlay starts
+/// invisible; the layout appliers position and reveal them when a bordered
+/// zone appears.
+fn underlay_initial_props(props: &mut HashMap<String, PropertyValue>, zorder: u32) {
+    props.insert("xpos".to_string(), PropertyValue::Int(0));
+    props.insert("ypos".to_string(), PropertyValue::Int(0));
+    props.insert("width".to_string(), PropertyValue::Int(1));
+    props.insert("height".to_string(), PropertyValue::Int(1));
+    props.insert("alpha".to_string(), PropertyValue::Float(0.0));
+    props.insert("zorder".to_string(), PropertyValue::UInt(zorder as u64));
+    props.insert(
+        "sizing-policy".to_string(),
+        PropertyValue::String("none".to_string()),
+    );
+}
+
 /// Build pad_properties for compositor sink pads (applied after linking).
 ///
 /// Since glvideomixerelement uses auto-created request pads (the linker uses
@@ -149,6 +166,19 @@ pub(super) fn build_pad_properties(
         );
     }
 
+    // --- Dist border underlay pads: sink_{N + DSK + i} ---
+    // Only present when PiPs are configured (see the pipeline builders).
+    // Hidden at build — zones are runtime-only.
+    if p.num_pips > 0 {
+        for i in 0..p.num_inputs {
+            let pad_name = format!("sink_{}", p.num_inputs + p.num_dsk_inputs + i);
+            underlay_initial_props(
+                dist_pads.entry(pad_name).or_default(),
+                vision_mixer::DIST_PIP_OVERLAY_ZORDER,
+            );
+        }
+    }
+
     // --- Multiview compositor pad properties ---
     let mv_pads = pad_props.entry(mv_comp_id).or_default();
 
@@ -282,8 +312,9 @@ pub(super) fn build_pad_properties(
     }
 
     // --- Overlay pad: fullscreen, highest zorder ---
+    let overlay_pad_idx = 2 * p.num_inputs + 1 + p.num_pips * p.num_inputs;
     {
-        let overlay_pad_name = format!("sink_{}", 2 * p.num_inputs + 1 + p.num_pips * p.num_inputs);
+        let overlay_pad_name = format!("sink_{}", overlay_pad_idx);
         let props = mv_pads.entry(overlay_pad_name).or_default();
         props.insert("xpos".to_string(), PropertyValue::Int(0));
         props.insert("ypos".to_string(), PropertyValue::Int(0));
@@ -296,5 +327,29 @@ pub(super) fn build_pad_properties(
         );
     }
 
+    // --- Multiview border underlay pads (PVW big + PiP tiles), hidden ---
+    if p.num_pips > 0 {
+        let mv_underlay_base = overlay_pad_idx + 1;
+        for i in 0..p.num_inputs {
+            let pad_name = format!("sink_{}", mv_underlay_base + i);
+            underlay_initial_props(
+                mv_pads.entry(pad_name).or_default(),
+                vision_mixer::MV_PVW_PIP_OVERLAY_ZORDER,
+            );
+        }
+        for pip_idx in 0..p.num_pips {
+            for i in 0..p.num_inputs {
+                let pad_name = format!(
+                    "sink_{}",
+                    mv_underlay_base + p.num_inputs * (1 + pip_idx) + i
+                );
+                underlay_initial_props(
+                    mv_pads.entry(pad_name).or_default(),
+                    vision_mixer::MV_PIP_OVERLAY_ZORDER,
+                );
+            }
+        }
+    }
+
     pad_props
 }
@@ -234,6 +234,56 @@ pub(super) fn build_cpu_pipeline(
     };
     // Link to mv_comp is added AFTER all other mv_comp links (pad ordering matters)
 
+    // --- Border underlay sources ---
+    // Zone borders render as solid-color compositor pads directly beneath
+    // their content pads (see `gst::underlay`). One tiny videotestsrc per
+    // (region, input); the border color is set at runtime via
+    // `foreground-color`. Non-live → contributes no latency. Only built when
+    // PiPs are configured — zones (and thus borders) cannot exist without
+    // them.
+    if p.num_pips > 0 {
+        let underlay_chains: Vec<String> = (0..p.num_inputs)
+            .map(|i| format!("underlay_dist_{}", i))
+            .chain((0..p.num_inputs).map(|i| format!("underlay_pvw_{}", i)))
+            .chain((0..p.num_pips).flat_map(|pip| {
+                (0..p.num_inputs)
+                    .map(move |i| format!("underlay_pip_{}_{}", pip, i))
+                    .collect::<Vec<_>>()
+            }))
+            .collect();
+        // Always RGBA — the compositor's convert pads handle per-pad format
+        // conversion, and an alpha-less forced output_format (I420/NV12)
+        // would silently drop the alpha of #RRGGBBAA border colors. Low
+        // framerate: the color only changes on border edits and the
+        // compositor keeps compositing the latest buffer between pushes.
+        let underlay_caps: gst::Caps =
+            "video/x-raw,format=RGBA,width=16,height=16,framerate=5/1,pixel-aspect-ratio=1/1"
+                .parse()
+                .map_err(|e| BlockBuildError::ElementCreation(format!("underlay caps: {}", e)))?;
+        for name in &underlay_chains {
+            let src_id = p.id(&format!("{}_src", name));
+            let cf_id = p.id(&format!("{}_caps", name));
+            let src = gst::ElementFactory::make("videotestsrc")
+                .name(&src_id)
+                .property("is-live", false)
+                .build()
+                .map_err(|e| BlockBuildError::ElementCreation(format!("{}: {}", src_id, e)))?;
+            src.set_property_from_str("pattern", "solid-color");
+            let cf = gst::ElementFactory::make("capsfilter")
+                .name(&cf_id)
+                .property("caps", &underlay_caps)
+                .build()
+                .map_err(|e| BlockBuildError::ElementCreation(format!("{}: {}", cf_id, e)))?;
+            elems.push((src_id.clone(), src));
+            elems.push((cf_id.clone(), cf));
+            links.push((
+                ElementPadRef::pad(&src_id, "src"),
+                ElementPadRef::pad(&cf_id, "sink"),
+            ));
+        }
+    }
+    // Links to the compositor pads are added below in pad-index order.
+
     // --- Per-input elements ---
     for i in 0..p.num_inputs {
         let q_id = p.id(&format!("queue_{}", i));
@@ -358,6 +408,21 @@ pub(super) fn build_cpu_pipeline(
         ));
     }
 
+    // Dist border underlays — after the DSK links so input i's underlay
+    // lands at sink_{num_inputs + num_dsk_inputs + i}.
+    if p.num_pips > 0 {
+        for i in 0..p.num_inputs {
+            let cf_id = p.id(&format!("underlay_dist_{}_caps", i));
+            links.push((
+                ElementPadRef::pad(&cf_id, "src"),
+                ElementPadRef::pad(
+                    &mixer_id,
+                    format!("sink_{}", p.num_inputs + p.num_dsk_inputs + i),
+                ),
+            ));
+        }
+    }
+
     // Multiview compositor thumbnails: tee_i.src_1 → queue → mv_comp
     for i in 0..p.num_inputs {
         let tee_id = p.id(&format!("tee_{}", i));
@@ -416,13 +481,36 @@ pub(super) fn build_cpu_pipeline(
         }
     }
 
-    // Overlay pad: last overlay element → mv_comp (must be last link for correct pad index)
+    // Overlay pad: last overlay element → mv_comp.
     let overlay_pad_idx = 2 * p.num_inputs + 1 + p.num_pips * p.num_inputs;
     links.push((
         ElementPadRef::pad(&overlay_last_id, "src"),
         ElementPadRef::pad(&mv_comp_id, format!("sink_{}", overlay_pad_idx)),
     ));
 
+    // Multiview border underlays — after the overlay pad: PVW underlays at
+    // sink_{2N+2+P+i}, then tile underlays at sink_{2N+2+P+N+pip*N+i}.
+    if p.num_pips > 0 {
+        let mv_underlay_base = overlay_pad_idx + 1;
+        for i in 0..p.num_inputs {
+            let cf_id = p.id(&format!("underlay_pvw_{}_caps", i));
+            links.push((
+                ElementPadRef::pad(&cf_id, "src"),
+                ElementPadRef::pad(&mv_comp_id, format!("sink_{}", mv_underlay_base + i)),
+            ));
+        }
+        for pip_idx in 0..p.num_pips {
+            for i in 0..p.num_inputs {
+                let cf_id = p.id(&format!("underlay_pip_{}_{}_caps", pip_idx, i));
+                let sink_idx = mv_underlay_base + p.num_inputs * (1 + pip_idx) + i;
+                links.push((
+                    ElementPadRef::pad(&cf_id, "src"),
+                    ElementPadRef::pad(&mv_comp_id, format!("sink_{}", sink_idx)),
+                ));
+            }
+        }
+    }
+
     // Multiview PGM big display: tee_pgm.src_1 → queue_pgm_mv → capsfilter_pgm_mv → mv_comp.sink_N
     // (capsfilter breaks caps query cycle back to PGM compositor)
     links.push((