Merge main into #1739; keep both footage re-exports (Cineon + VIDEO_EXTENSIONS) and main's gaps.md localization row with the PR's AVI row

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/automation/src/confine.rs

@@ -30,10 +30,9 @@ pub struct Confinement {
     write: Vec<PathBuf>,
 }
 
-/// Commands that run code, act outside the project or open other applications.
+/// Commands that run code, act outside the project or open other applications, besides the
+/// commands that run scripts ([`effectcraft_engine::commands::scripts::RUNS_SCRIPTS`]).
 const REFUSED: &[&str] = &[
-    "script.run",
-    "file.runScript",
     "file.installScript",
     "file.installScriptUIPanel",
     "file.uninstallScript",
@@ -167,7 +166,7 @@ impl Confinement {
     /// Check engine command `id` with `params` before it runs. Returns what must still be looked
     /// up and passed to [`Confinement::check_lookup`] for commands that write implicitly.
     pub fn check_command(&self, id: &str, params: &Value) -> Result<Option<Lookup>> {
-        if REFUSED.contains(&id) {
+        if REFUSED.contains(&id) || effectcraft_engine::commands::scripts::RUNS_SCRIPTS.contains(&id) {
             return Err(Error::BadArgs(format!("`{id}` is not available while file access is confined (--automation-read-root/--automation-write-root)")));
         }
         // Scripts can't grant themselves the access the user withheld
@@ -397,6 +396,7 @@ mod tests {
             let classified = keys_of(READS, id).is_some()
                 || keys_of(WRITES, id).is_some()
                 || REFUSED.contains(&id)
+                || effectcraft_engine::commands::scripts::RUNS_SCRIPTS.contains(&id)
                 || IMPLICIT_WRITES.contains(&id)
                 || id.starts_with("renderQueue.")
                 || id == "render.addOutputModule"

crates/automation/src/tests.rs

@@ -1412,6 +1412,18 @@ fn automation_roots_confine_file_access() {
     // Scripts can read and write anything: refused.
     denied(&mut s, "run_script", json!({"code": "1 + 1"}));
     denied(&mut s, "execute_command", json!({"command": "file.runScript", "params": {"path": p(&read, "x.jsx")}}));
+    for (id, params) in [
+        ("file.runStartupScripts", json!({})),
+        ("file.runShutdownScripts", json!({})),
+        // ScriptUI panels run their script when they open.
+        ("window.scriptPanel", json!({"name": "Layer Tools.jsx"})),
+        ("window.restoreScriptPanels", json!({})),
+    ] {
+        let msg = denied(&mut s, "execute_command", json!({"command": id, "params": params}));
+        assert!(msg.contains("not available while file access is confined"), "{id}: {msg}");
+        let msg = denied(&mut s, "batch", json!({"steps": [{"command": id, "params": params}]}));
+        assert!(msg.contains("not available while file access is confined"), "{id}: {msg}");
+    }
     // Writes to the files the agent named: none outside.
     assert_eq!(std::fs::read_dir(&outside).unwrap().count(), 1, "only the unconfined save");
     let _ = std::fs::remove_dir_all(&base);

crates/effects/src/distort2.rs

@@ -95,6 +95,9 @@ fn turbulent_displace(ctx: &EffectCtx, mut b: Buf) -> Buf {
     let size = (ctx.params.f("size") * b.scale).max(1.0);
     if ctx.params.b("resizeLayer") && !ctx.adjustment {
         b.pad(amount.abs().ceil() as u32 + 1);
+    } else {
+        // Room for pixels displaced past the content, up to the layer's edge (#1205).
+        b.pad(crate::cover_pad(ctx, [b.img.width, b.img.height], b.offset, b.scale, amount.abs().ceil() as u32 + 1));
     }
     let off = b.to_px(ctx.params.v2("offset"));
     let oct = ctx.params.f("complexity").clamp(1.0, 10.0);

crates/effects/src/lib.rs

@@ -312,6 +312,19 @@ impl Buf {
         self.offset[0] += l as f64;
         self.offset[1] += t as f64;
     }
+    /// Grow by `left` and `top` transparent pixels on those sides only.
+    pub fn grow_left_top(&mut self, left: u32, top: u32) {
+        self.pad_sides([left, top, 0, 0]);
+    }
+    /// Give the buffer the pixel-grid phase (modulo [`GRID_ALIGN`]) that [`Buf::cover`] of
+    /// `size` would, by growing left/top only ([`align_plan`]). A downscaled layer is resampled
+    /// through a pyramid whose 2x2 blocks follow the buffer's grid, so a buffer that starts at
+    /// its content's corner instead of the cover's resamples to different pixels (#1205).
+    pub fn align(&mut self, size: [f64; 2]) {
+        if let Some((l, t)) = align_plan(self.offset, self.scale, size, self.img.width, self.img.height) {
+            self.grow_left_top(l, t);
+        }
+    }
     /// Grow by `pad` transparent pixels on every side, within [`pad_within_budget`] and as
     /// clamped by [`Image::effective_pad`].
     pub fn pad(&mut self, pad: u32) {
@@ -377,6 +390,33 @@ pub fn adjustment_crop(offset: [f64; 2], canvas_offset: [f64; 2], size: (u32, u3
     Some((dx as i64, dy as i64))
 }
 
+/// Effects that grow their own buffer by what they need (blur and glow margins, Repeat Edge
+/// Pixels through [`Buf::cover`], displacement through [`cover_pad`]): a stack of only these
+/// skips the renderer's cover of the whole layer rectangle (#1205).
+pub const SKIPS_COVER: &[&str] = &["ec.blur.gaussian", "ec.blur.fastbox", "ec.stylize.glow", "ec.distort.turbulentdisplace"];
+
+/// The grid phase [`Buf::align`] keeps and the step [`cover_pad`] grows in: covers the levels
+/// of the resampling pyramid used for downscaled layers.
+pub const GRID_ALIGN: u32 = 64;
+
+/// Left/top growth giving a buffer [`cover_plan`]'s grid phase modulo [`GRID_ALIGN`]; `None`
+/// when there is nothing to add.
+pub fn align_plan(offset: [f64; 2], scale: f64, size: [f64; 2], width: u32, height: u32) -> Option<(u32, u32)> {
+    let (dx, dy, _, _) = cover_plan(offset, scale, size, width, height)?;
+    let (l, t) = (dx % GRID_ALIGN, dy % GRID_ALIGN);
+    (l != 0 || t != 0).then_some((l, t))
+}
+
+/// Padding for an effect that moves pixels up to `want` past the content (not an adjustment
+/// layer): `want`, capped at what reaches the layer rectangle, in whole [`GRID_ALIGN`] steps so
+/// the grid phase stays. 0 once the buffer covers the layer.
+pub fn cover_pad(ctx: &EffectCtx, size: [u32; 2], offset: [f64; 2], scale: f64, want: u32) -> u32 {
+    if ctx.adjustment {
+        return 0;
+    }
+    want.min(util::layer_cover_pad(ctx, size, offset, scale)).div_ceil(GRID_ALIGN) * GRID_ALIGN
+}
+
 /// Where [`Buf::cover`] would take a buffer: shift its pixels by `(dx, dy)` and resize it to
 /// `width` × `height` so it spans the `size`-layer-pixel region that starts at its offset — the
 /// whole layer rectangle, which a sized source's buffer already is. `None` when the buffer
@@ -555,6 +595,15 @@ pub struct EffectSpec {
     pub float: bool,
 }
 
+impl EffectSpec {
+    /// True when this effect grows its own buffer (blur/glow margins, Repeat Edge
+    /// [`Buf::cover`], displacement [`cover_pad`]) so a stack of only these can skip the
+    /// renderer's full-layer cover and keep the pyramid grid phase (#1205).
+    pub fn skips_cover(&self) -> bool {
+        SKIPS_COVER.contains(&self.id)
+    }
+}
+
 pub(crate) fn p(id: &'static str, name: &'static str, default: Value, ui: ParamUi) -> ParamSpec {
     ParamSpec { id, name, default, ui }
 }
@@ -1583,4 +1632,24 @@ mod tests {
         assert_eq!(g.get("noiseSourceLayerSource").map(|p| p.value.clone()), Some(Value::Enum(0)));
         assert_eq!(g.props().filter(|p| p.match_id == "noiseSourceLayerSource").count(), 1);
     }
+
+    #[test]
+    fn align_plan_is_cover_shift_mod_grid() {
+        // Content inset from the layer origin: pixel 0 maps to layer (50, 30).
+        let offset = [-50.0, -30.0];
+        let scale = 1.0;
+        let size = [1920.0, 1080.0];
+        let (dx, dy, _, _) = cover_plan(offset, scale, size, 80, 40).unwrap();
+        assert_eq!((dx, dy), (50, 30));
+        assert_eq!(align_plan(offset, scale, size, 80, 40), Some((50, 30)));
+        assert_eq!(align_plan([-64.0, -128.0], 1.0, size, 80, 40), None);
+    }
+
+    #[test]
+    fn known_margin_effects_skip_cover_and_twirl_does_not() {
+        for id in SKIPS_COVER {
+            assert!(find(id).expect(id).skips_cover(), "{id}");
+        }
+        assert!(!find("ec.distort.twirl").unwrap().skips_cover());
+    }
 }

crates/effects/src/misc.rs

@@ -34,6 +34,9 @@ fn gaussian(ctx: &EffectCtx, mut b: Buf) -> Buf {
     let repeat = ctx.params.b("repeatEdge");
     if !repeat && !ctx.adjustment {
         b.pad((s * 3.0).ceil() as u32);
+    } else if repeat && !ctx.adjustment {
+        // The edge it repeats is the layer's, not the painted content's (#1205).
+        b.cover(ctx.layer_size);
     }
     let (sx, sy) = (s * kx, s * ky);
     // Small sigmas: integer-radius box passes would step (and do nothing below ~0.6 px), so sample the kernel (#1939).
@@ -60,6 +63,9 @@ fn box_blur(ctx: &EffectCtx, mut b: Buf) -> Buf {
     if !repeat && !ctx.adjustment {
         let reach = if frac > 0.0 { r + 1 } else { r };
         b.pad((reach * it) as u32 + 1);
+    } else if repeat && !ctx.adjustment {
+        // The edge it repeats is the layer's, not the painted content's (#1205).
+        b.cover(ctx.layer_size);
     }
     let edge = repeat || ctx.adjustment;
     let lo = effectcraft_raster::box_blur(&b.img, r * kx as usize, r * ky as usize, it, edge);

crates/effects/src/sim/tests.rs

@@ -97,6 +97,21 @@ fn bubbles_rise() {
     assert!(y0 >= 0.0 && y1 >= 0.0 && (y1 < y0 || y0 < 8.0), "{y0} -> {y1}");
 }
 
+/// #2024: bubbles near the layer's edges show its edge pixels, not the pale colour that stands
+/// in for transparent ones.
+#[test]
+fn bubbles_near_edges_show_the_layer() {
+    let blue = Image::filled(40, 40, [0.0, 0.0, 1.0, 1.0]);
+    let pale = [0, 1].map(|reflection| {
+        let vals = [("bubbleAmount", num(200.0)), ("bubbleSize", num(3.0)), ("reflectionType", Value::Enum(reflection))];
+        let a = run("ec.sim.ccbubbles", &vals, blue.clone(), 0.3);
+        assert!(a.data.iter().any(|p| p[3] > 0.5), "bubbles drawn");
+        // Blue plus the white highlight keeps blue − red = alpha; the pale colour leaves 0.2 · alpha.
+        a.data.iter().filter(|p| (p[2] - p[0] - p[3]).abs() > 1e-4).count()
+    });
+    assert_eq!(pale, [0, 0], "pale bubble pixels (liquid, metal)");
+}
+
 #[test]
 fn drizzle_ripples() {
     let a = run("ec.sim.ccdrizzle", &[], ramp(48, 48), 0.6);

crates/effects/src/sim/weather.rs

@@ -182,7 +182,7 @@ pub(super) fn bubbles(ctx: &EffectCtx, mut b: Buf) -> Buf {
             // Liquid refracts (inverted, magnified), metal reflects (wide-angle mirror).
             let k = if metal { 1.6 } else { -0.7 };
             let nz = (1.0 - d2).max(0.0).sqrt();
-            let p = src.sample_bilinear((q.sx + dx * q.r * k) as f64, (q.sy + dy * q.r * k) as f64);
+            let p = src.sample_bilinear_clamped((q.sx + dx * q.r * k) as f64, (q.sy + dy * q.r * k) as f64);
             let (c, sa) = unpremul(p);
             let mut c = if sa <= 0.0 { [0.6, 0.7, 0.8] } else { c };
             let mut a = cov;

crates/effects/src/utility.rs

@@ -100,17 +100,11 @@ impl Cineon {
     fn knee(&self) -> f32 {
         1.0 - (self.rolloff / 100.0).clamp(0.0, 0.99)
     }
-    /// Normalised code value (code / 1023) → linear.
+    /// Normalized code value (code / 1023) → linear, raised to `1.7 / gamma`
+    /// ([`effectcraft_project::cineon_log_to_lin`], which Interpret Footage ▸ Cineon Settings
+    /// also uses with `1 / gamma`).
     pub fn log_to_lin(&self, v: f32) -> f32 {
-        let off = self.offset();
-        let code = v * 1023.0;
-        let mut lin = (10f32.powf((code - self.white) * 0.002 / 0.6) - off) / (1.0 - off).max(1e-6);
-        lin = lin.max(0.0).powf(1.7 / self.gamma.max(0.01));
-        let k = self.knee();
-        if k < 1.0 && lin > k {
-            let w = 1.0 - k;
-            lin = k + w * (1.0 - (-(lin - k) / w).exp());
-        }
+        let lin = effectcraft_project::cineon_log_to_lin(v, self.black, self.white, 1.7, self.gamma, self.rolloff);
         self.ib + (self.iw - self.ib) * lin
     }
     /// Linear → normalised code value.
@@ -495,6 +489,87 @@ mod tests {
         assert!(c.log_to_lin(95.0 / 1023.0).abs() < 1e-4);
     }
 
+    /// Interpret Footage ▸ Cineon Settings and the Cineon Converter's Log to Linear give the same
+    /// values for the same points and Highlight Rolloff when the converter's Gamma is 1.7 times
+    /// Cineon Settings' Gamma: the converter's default 1.7 and Cineon Settings' Gamma 1 both give
+    /// linear light (code 400 is 0.10251).
+    #[test]
+    fn cineon_converter_matches_interpret_footage() {
+        let codes = [0.0f32, 95.0, 250.0, 400.0, 560.0, 685.0, 800.0, 1023.0];
+        for (gamma, rolloff) in [(1.0, 20.0), (1.0, 0.0), (1.7, 50.0), (2.4, 50.0)] {
+            let mut img = Image::new(codes.len() as u32, 1);
+            for (x, code) in codes.iter().enumerate() {
+                let v = code / 1023.0;
+                img.set(x as u32, 0, [v, v, v, 1.0]);
+            }
+            let vals = [("conversionType", Value::Enum(1)), ("gamma", num(gamma * 1.7)), ("highlightRolloff", num(rolloff))];
+            let out = run("ec.utility.cineon", &vals, img);
+            let settings = effectcraft_project::CineonSettings { log_conversion: true, gamma: gamma as f32, rolloff: rolloff as f32, ..Default::default() };
+            for (x, code) in codes.iter().enumerate() {
+                let footage = settings.convert(code / 1023.0);
+                let effect = out.img.data[x][0];
+                assert!((footage - effect).abs() < 1e-6, "gamma {gamma}, rolloff {rolloff}, code {code}: {footage} vs {effect}");
+            }
+        }
+        let linear = effectcraft_project::CineonSettings { gamma: 1.0, rolloff: 0.0, ..Default::default() };
+        assert!((linear.convert(400.0 / 1023.0) - 0.10251).abs() < 1e-4);
+    }
+
+    /// The Cineon Converter gives the same values as before Cineon Settings shared its
+    /// log-to-linear function, at the default Gamma (1.7) and at Gamma 2.4, for all three
+    /// conversion types.
+    #[test]
+    fn cineon_converter_output_is_unchanged() {
+        fn log_to_lin(v: f32, gamma: f32, rolloff: f32, black: f32, white: f32) -> f32 {
+            let off = 10f32.powf((black - white) * 0.002 / 0.6);
+            let mut lin = (10f32.powf((v * 1023.0 - white) * 0.002 / 0.6) - off) / (1.0 - off).max(1e-6);
+            lin = lin.max(0.0).powf(1.7 / gamma.max(0.01));
+            let k = 1.0 - (rolloff / 100.0).clamp(0.0, 0.99);
+            if k < 1.0 && lin > k {
+                let w = 1.0 - k;
+                lin = k + w * (1.0 - (-(lin - k) / w).exp());
+            }
+            lin
+        }
+        fn lin_to_log(v: f32, gamma: f32, rolloff: f32, black: f32, white: f32) -> f32 {
+            let off = 10f32.powf((black - white) * 0.002 / 0.6);
+            let mut lin = v;
+            let k = 1.0 - (rolloff / 100.0).clamp(0.0, 0.99);
+            if k < 1.0 && lin > k {
+                let w = 1.0 - k;
+                lin = k - w * (1.0 - (lin - k) / w).max(1e-6).ln();
+            }
+            lin = lin.max(0.0).powf(gamma.max(0.01) / 1.7);
+            (white + (lin * (1.0 - off) + off).max(1e-9).log10() * 0.6 / 0.002) / 1023.0
+        }
+        let codes = [0.0f32, 95.0, 250.0, 400.0, 560.0, 685.0, 800.0, 1023.0];
+        for gamma in [None, Some(2.4)] {
+            for kind in 0..3 {
+                let mut img = Image::new(codes.len() as u32, 1);
+                for (x, code) in codes.iter().enumerate() {
+                    let v = code / 1023.0;
+                    img.set(x as u32, 0, [v, v, v, 1.0]);
+                }
+                let mut vals = vec![("conversionType", Value::Enum(kind))];
+                if let Some(g) = gamma {
+                    vals.push(("gamma", num(g)));
+                }
+                let out = run("ec.utility.cineon", &vals, img);
+                let g = gamma.unwrap_or(1.7) as f32;
+                for (x, code) in codes.iter().enumerate() {
+                    let v = code / 1023.0;
+                    let want = match kind {
+                        0 => lin_to_log(v, g, 20.0, 95.0, 685.0),
+                        1 => log_to_lin(v, g, 20.0, 95.0, 685.0),
+                        _ => lin_to_log(log_to_lin(v, g, 20.0, 95.0, 685.0), 1.7, 20.0, 95.0, 685.0),
+                    };
+                    let got = out.img.data[x][0];
+                    assert!((want - got).abs() < 1e-6, "gamma {g}, type {kind}, code {code}: {want} vs {got}");
+                }
+            }
+        }
+    }
+
     #[test]
     fn hdr_compression_behaviour() {
         let mut img = Image::new(2, 1);

crates/effects/tests/it/sim_golden.rs

@@ -433,26 +433,26 @@ const GOLDEN: &[(&str, u64)] = &[
     ("ec.sim.ccstarburst/1/32bpc/t1.5", 0x5c39f8b1bd0e9e43),
     ("ec.sim.ccstarburst/1/32bpc/t0.8", 0xdf20aa9dcf4b3e22),
     ("ec.sim.ccstarburst/1/32bpc/t2.2", 0x4fa441737bfcb64d),
-    ("ec.sim.ccbubbles/0/8bpc/t0.5", 0xdcd187e75eeb2fae),
-    ("ec.sim.ccbubbles/0/8bpc/t1.5", 0x835ca088747736ed),
-    ("ec.sim.ccbubbles/0/8bpc/t0.8", 0x5cbb1a6fbb77b41d),
-    ("ec.sim.ccbubbles/0/8bpc/t2.2", 0x3b168068f5bfa533),
-    ("ec.sim.ccbubbles/0/32bpc/t0.5", 0x524b84d14edd77e2),
-    ("ec.sim.ccbubbles/0/32bpc/t1.5", 0xfd7a17f0d40f2a27),
-    ("ec.sim.ccbubbles/0/32bpc/t0.8", 0x70dd2b2b4ff0f7ce),
-    ("ec.sim.ccbubbles/0/32bpc/t2.2", 0xae21dd5cc2c2c07c),
+    ("ec.sim.ccbubbles/0/8bpc/t0.5", 0x6cb63df0c062fdf4),
+    ("ec.sim.ccbubbles/0/8bpc/t1.5", 0x5bb1350114234ac3),
+    ("ec.sim.ccbubbles/0/8bpc/t0.8", 0xaa824d49f12c4156),
+    ("ec.sim.ccbubbles/0/8bpc/t2.2", 0x3528577358c4fc90),
+    ("ec.sim.ccbubbles/0/32bpc/t0.5", 0xdcd8e71222c13a9a),
+    ("ec.sim.ccbubbles/0/32bpc/t1.5", 0xd09565e124d8f5db),
+    ("ec.sim.ccbubbles/0/32bpc/t0.8", 0x91242f8e1fd0ad84),
+    ("ec.sim.ccbubbles/0/32bpc/t2.2", 0x1f9782131e62149d),
     ("ec.sim.ccbubbles/0/8bpc/half/t0.5", 0x931b4ca707604220),
     ("ec.sim.ccbubbles/0/8bpc/half/t1.5", 0x21c25d4555abebe9),
     ("ec.sim.ccbubbles/0/8bpc/half/t0.8", 0x7e05972683359632),
     ("ec.sim.ccbubbles/0/8bpc/half/t2.2", 0xadc4f7219dab4921),
-    ("ec.sim.ccbubbles/1/8bpc/t0.5", 0x89d27a2fe2011067),
-    ("ec.sim.ccbubbles/1/8bpc/t1.5", 0x2bbfee897bf5bf6e),
-    ("ec.sim.ccbubbles/1/8bpc/t0.8", 0x26cc704e7b06fffc),
-    ("ec.sim.ccbubbles/1/8bpc/t2.2", 0x959d331545d96479),
-    ("ec.sim.ccbubbles/1/32bpc/t0.5", 0xaf486cebfcbf4641),
-    ("ec.sim.ccbubbles/1/32bpc/t1.5", 0xe150e9fdb558036f),
-    ("ec.sim.ccbubbles/1/32bpc/t0.8", 0x6395f3967cb24284),
-    ("ec.sim.ccbubbles/1/32bpc/t2.2", 0x68a55894d86ffb9e),
+    ("ec.sim.ccbubbles/1/8bpc/t0.5", 0x2f5415c679ff0980),
+    ("ec.sim.ccbubbles/1/8bpc/t1.5", 0xfcfc354dcd22e6d0),
+    ("ec.sim.ccbubbles/1/8bpc/t0.8", 0xdf90fd57c217019c),
+    ("ec.sim.ccbubbles/1/8bpc/t2.2", 0xd365c88c12219802),
+    ("ec.sim.ccbubbles/1/32bpc/t0.5", 0x50f20497f40bb46d),
+    ("ec.sim.ccbubbles/1/32bpc/t1.5", 0x74760599ffba220a),
+    ("ec.sim.ccbubbles/1/32bpc/t0.8", 0x028de52900ed8618),
+    ("ec.sim.ccbubbles/1/32bpc/t2.2", 0xaf0e21d9a7f625fe),
     ("ec.sim.ccdrizzle/0/8bpc/t0.5", 0x2bdfbc17d92b65b5),
     ("ec.sim.ccdrizzle/0/8bpc/t1.5", 0x8c354c46f99e35d3),
     ("ec.sim.ccdrizzle/0/8bpc/t0.8", 0x891f331ba47ee557),

crates/engine/src/analysis/tracking.rs

@@ -197,7 +197,8 @@ pub(crate) struct Work {
 }
 
 /// The layer's source frame at comp time `t` at 100 % (layer pixels + offset = image pixels).
-/// Footage at its native size is used straight from the footage source (no copy).
+/// Footage at its native size is used straight from the footage source (no copy unless its
+/// Cineon Settings convert it).
 pub(crate) fn source_frame(
     r: &Renderer,
     project: &Project,
@@ -215,7 +216,7 @@ pub(crate) fn source_frame(
         && img.width == f.width
         && img.height == f.height
     {
-        return Some((img, [0.0; 2]));
+        return Some((effectcraft_render::cineon_frame(img, f), [0.0; 2]));
     }
     let buf = r.layer_source(&ctx, layer)?;
     if (buf.scale - 1.0).abs() > 1e-9 && buf.scale > 0.0 {

crates/engine/src/cmd/app_more.rs

@@ -240,7 +240,7 @@ fn replace_with_precomp(s: &mut Session, p: &Value) -> Result<Value> {
             let ids: Vec<ItemId> = proj.items.keys().copied().filter(|c| *c != comp).collect();
             for cid in ids {
                 if let Some(c) = proj.comp_mut(cid) {
-                    for l in c.layers.iter_mut().filter(|l| is_user(l)) {
+                    for l in c.layers.iter_mut_where(|l| is_user(l)) {
                         l.source = LayerSource::Comp { item: comp };
                         n += 1;
                     }

crates/engine/src/cmd/batch.rs

@@ -9,8 +9,9 @@ use serde_json::{Value, json};
 use super::{CommandSpec, always, bad, str_p};
 use crate::{EngineError, Result, Session};
 
-/// Commands that can't run inside a batch (they replace the project or nest batches).
-const NOT_IN_BATCH: &[&str] = &["engine.batch", "file.runScript", "script.run"];
+/// Commands that can't run inside a batch (they nest batches), besides the commands that run
+/// scripts ([`super::scripts::RUNS_SCRIPTS`]).
+const NOT_IN_BATCH: &[&str] = &["engine.batch"];
 
 /// Resolve a `$N` / `$N.key.0.key` reference against the results so far.
 fn reference(s: &str, results: &[Value]) -> Option<Result<Value>> {
@@ -78,7 +79,7 @@ fn batch(s: &mut Session, p: &Value) -> Result<Value> {
                 .or_else(|| step.get("id"))
                 .and_then(Value::as_str)
                 .ok_or_else(|| bad("engine.batch", "each step needs `command` (a command id)"))?;
-            if NOT_IN_BATCH.contains(&id) {
+            if NOT_IN_BATCH.contains(&id) || super::scripts::RUNS_SCRIPTS.contains(&id) {
                 return Err(bad("engine.batch", format!("`{id}` can't run inside a batch")));
             }
             let params = substitute(step.get("params").unwrap_or(&json!({})), results)?;

crates/engine/src/cmd/comp.rs

@@ -35,7 +35,7 @@ fn apply_settings(c: &mut Comp, p: &Value) {
         let dx = (c.width as f64 - ow as f64) * (a % 3) as f64 / 2.0;
         let dy = (c.height as f64 - oh as f64) * (a / 3) as f64 / 2.0;
         if dx != 0.0 || dy != 0.0 {
-            for l in c.layers.iter_mut().filter(|l| l.parent.is_none()) {
+            for l in c.layers.iter_mut_where(|l| l.parent.is_none()) {
                 if let Some(tr) = l.transform_mut() {
                     super::layer::offset_position(tr, dx, dy);
                 }

crates/engine/src/cmd/comp_more.rs

@@ -25,7 +25,7 @@ fn crop(s: &mut Session, cid: effectcraft_project::ItemId, r: [f64; 4], label: &
         let (old_w, old_h) = (c.width, c.height);
         c.width = w;
         c.height = h;
-        for l in c.layers.iter_mut().filter(|l| l.parent.is_none()) {
+        for l in c.layers.iter_mut_where(|l| l.parent.is_none()) {
             if let Some(tr) = l.transform_mut() {
                 super::layer::offset_position(tr, -x, -y);
             }

crates/engine/src/cmd/edit.rs

@@ -90,7 +90,7 @@ fn deselect_all(s: &mut Session, _: &Value) -> Result<Value> {
 fn relink_copies(comp: &mut Comp, map: &[(LayerId, LayerId)]) {
     let present: Vec<LayerId> = comp.layers.iter().map(|l| l.id).collect();
     let link = |id: LayerId| map.iter().find(|(o, _)| *o == id).map(|(_, c)| *c).or(present.contains(&id).then_some(id));
-    for l in comp.layers.iter_mut().filter(|l| map.iter().any(|(_, c)| *c == l.id)) {
+    for l in comp.layers.iter_mut_where(|l| map.iter().any(|(_, c)| *c == l.id)) {
         l.parent = l.parent.and_then(link);
         l.track_matte = l.track_matte.and_then(|m| link(m.layer).map(|layer| TrackMatte { layer, ..m }));
     }
@@ -685,7 +685,7 @@ fn label(s: &mut Session, p: &Value) -> Result<Value> {
             }
         }
         if let Some(comp) = proj.comp_mut(cid) {
-            for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+            for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
                 l.label = lab;
             }
         }

crates/engine/src/cmd/file.rs

@@ -125,7 +125,8 @@ fn revert(s: &mut Session, _: &Value) -> Result<Value> {
 }
 
 /// File ▸ Import; with `addToComp` (files dropped on the Timeline or the Composition viewer) they
-/// also become layers of the active comp ([`add_to_comp`]).
+/// also become layers of the active comp ([`add_to_comp`]); with `newComp` (the empty viewer's
+/// New Composition From Footage) they become one new composition instead ([`new_comp`]).
 ///
 /// With `background` (files dropped on the window or picked in the Import dialog) the files are
 /// probed on a background thread, so decoding a slow video doesn't freeze the app: the job shows
@@ -175,10 +176,10 @@ fn import_cmd(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(r)
 }
 
-/// After an import (its result `r`): with `addToComp`, the new items become layers of `target`;
-/// what couldn't be added joins the result's errors.
+/// After an import (its result `r`): with `newComp`, the new items become one new composition;
+/// otherwise with `addToComp`, layers of `target`. What couldn't be added joins the result's errors.
 fn finish_import(s: &mut Session, r: &mut Value, target: Option<ItemId>, p: &Value) {
-    let errors = add_to_comp(s, r, target, p);
+    let errors = if b_p(p, "newComp").unwrap_or(false) { new_comp(s, r) } else { add_to_comp(s, r, target, p) };
     if !errors.is_empty()
         && let Some(e) = r.get_mut("errors").and_then(Value::as_array_mut)
     {
@@ -192,18 +193,7 @@ fn finish_import(s: &mut Session, r: &mut Value, target: Option<ItemId>, p: &Val
 /// Project panel) and the other footage. `target` stays open. Returns what couldn't be added.
 pub(crate) fn add_to_comp(s: &mut Session, r: &Value, target: Option<ItemId>, p: &Value) -> Vec<String> {
     let Some(cid) = target.filter(|_| p.get("addToComp").and_then(Value::as_bool).unwrap_or(false)) else { return vec![] };
-    let ids = |k: &str| r.get(k).and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_u64).collect::<Vec<u64>>();
-    let comps = ids("comps");
-    let in_comps: std::collections::HashSet<u64> = comps
-        .iter()
-        .filter_map(|c| s.project.comp(ItemId(*c)))
-        .flat_map(|c| c.layers.iter())
-        .filter_map(|l| match l.source {
-            LayerSource::Footage { item } | LayerSource::Comp { item } | LayerSource::Solid { item } => Some(item.0),
-            _ => None,
-        })
-        .collect();
-    let add: Vec<u64> = comps.iter().copied().chain(ids("items").into_iter().filter(|i| !in_comps.contains(i))).collect();
+    let add = imported(s, r);
     let mut errors = vec![];
     for (k, item) in add.into_iter().enumerate() {
         let mut params = json!({"comp": cid.0, "item": item, "time": p.get("time"), "position": p.get("position")});
@@ -220,6 +210,55 @@ pub(crate) fn add_to_comp(s: &mut Session, r: &Value, target: Option<ItemId>, p:
     errors
 }
 
+/// What an import (its result `r`) made that belongs in a comp: the comps of layered files
+/// (their layers' footage, in their precomps too, stays in the Project panel), then the other items,
+/// without those comps again or the files' folders.
+fn imported(s: &Session, r: &Value) -> Vec<u64> {
+    let ids = |k: &str| r.get(k).and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_u64).collect::<Vec<u64>>();
+    let comps = ids("comps");
+    let mut in_comps = std::collections::HashSet::new();
+    let mut todo = comps.clone();
+    while let Some(c) = todo.pop() {
+        for l in s.project.comp(ItemId(c)).into_iter().flat_map(|c| c.layers.iter()) {
+            match l.source {
+                LayerSource::Comp { item } if in_comps.insert(item.0) => todo.push(item.0),
+                LayerSource::Footage { item } | LayerSource::Solid { item } => {
+                    in_comps.insert(item.0);
+                }
+                _ => {}
+            }
+        }
+    }
+    let rest = ids("items").into_iter().filter(|i| !in_comps.contains(i) && !comps.contains(i) && !s.project.item(ItemId(*i)).is_some_and(|it| it.is_folder()));
+    comps.iter().copied().chain(rest).collect()
+}
+
+/// With `newComp`, make one composition of the footage and solids an import (its result `r`)
+/// made, as New Comp from Selection does with `single` (first item on top, its settings). A comp
+/// the import made (a layered file) already is the composition, so it stays out, as does data
+/// footage; none left, no new comp. Returns what went wrong.
+fn new_comp(s: &mut Session, r: &Value) -> Vec<String> {
+    let items: Vec<ItemId> = imported(s, r)
+        .into_iter()
+        .map(ItemId)
+        .filter(|i| {
+            s.project.item(*i).is_some_and(|it| match &it.kind {
+                ItemKind::Footage(f) => f.kind != FootageKind::Data,
+                ItemKind::Solid(_) => true,
+                ItemKind::Comp(_) | ItemKind::Folder => false,
+            })
+        })
+        .collect();
+    if items.is_empty() {
+        return vec![];
+    }
+    s.state.project_selection = items;
+    match s.execute("file.newCompFromSelection", json!({"single": true})) {
+        Ok(_) => vec![],
+        Err(e) => vec![e.to_string()],
+    }
+}
+
 /// File ▸ Import, all in one go (scripts and commands built on it); see [`import_cmd`].
 pub(crate) fn import(s: &mut Session, p: &Value) -> Result<Value> {
     let pending = prepare_import(s, p)?;
@@ -746,7 +785,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "File...",
             ["File", "Import"],
             Some("Cmd+I"),
-            "{paths: [string] (files or folders), sequence?: bool (the Sequence checkbox: true imports numbered stills of one run as one image sequence, one picked file bringing its whole run and several picked files that range; default false: picked or dropped files import as stills, as in After Effects; folders' runs import as sequences; false imports stills and a folder's files individually), alphabetical?: bool (Force Alphabetical Order: every image of that type in the folder, by name), frameRate?: fps (image sequences; default Settings ▸ Import ▸ Sequence Footage), importAs?: footage|composition|compositionLayerSizes (Photoshop, PDF, Illustrator and EPS files), layer?: name|index (footage of one Photoshop layer), page?: number from 1 (PDF / Illustrator page), drag?: bool (dropped files: Settings ▸ Import ▸ Default Drag Import As; files import as stills unless sequence), addToComp?: bool (also add them to the active comp, at time?, index?, position? as in layer.addItem), background?: bool (probe the files in a background job, jobs.list / jobs.wait; returns {job})}",
+            "{paths: [string] (files or folders), sequence?: bool (the Sequence checkbox: true imports numbered stills of one run as one image sequence, one picked file bringing its whole run and several picked files that range; default false: picked or dropped files import as stills, as in After Effects; folders' runs import as sequences; false imports stills and a folder's files individually), alphabetical?: bool (Force Alphabetical Order: every image of that type in the folder, by name), frameRate?: fps (image sequences; default Settings ▸ Import ▸ Sequence Footage), importAs?: footage|composition|compositionLayerSizes (Photoshop, PDF, Illustrator and EPS files), layer?: name|index (footage of one Photoshop layer), page?: number from 1 (PDF / Illustrator page), drag?: bool (dropped files: Settings ▸ Import ▸ Default Drag Import As; files import as stills unless sequence), addToComp?: bool (also add them to the active comp, at time?, index?, position? as in layer.addItem), newComp?: bool (make one new composition of the footage and solids imported, as file.newCompFromSelection with single; a layered file imported as a composition is that composition and gets no other; takes precedence over addToComp), background?: bool (probe the files in a background job, jobs.list / jobs.wait; returns {job})}",
             always,
             import_cmd
         ),

crates/engine/src/cmd/file_more.rs

@@ -5,7 +5,7 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use effectcraft_color::Label;
-use effectcraft_project::{AlphaMode, Comp, Footage, FootageKind, ItemId, ItemKind, LayerSource, Project, Solid, limits};
+use effectcraft_project::{AlphaMode, CineonSettings, CineonUnits, Comp, Footage, FootageKind, ItemId, ItemKind, LayerSource, Project, Solid, limits};
 use effectcraft_time::{FrameRate, Tick};
 use serde_json::{Value, json};
 
@@ -501,7 +501,7 @@ fn run_script(s: &mut Session, p: &Value) -> Result<Value> {
             }
             _ => return Err(bad("file.runScript", format!("step {}: needs `command`", i + 1))),
         };
-        if id == "file.runScript" || id == "script.run" {
+        if super::scripts::RUNS_SCRIPTS.contains(&id.as_str()) {
             return Err(bad("file.runScript", "scripts can't run scripts"));
         }
         let r = if from_file { s.execute_for_script(&id, params) } else { s.execute(&id, params) };
@@ -536,7 +536,7 @@ fn is_jsxbin(name: &str) -> bool {
 }
 
 /// A script error becomes a toast and a command error.
-fn report_js(s: &mut Session, name: &str, out: Value) -> Result<Value> {
+pub(crate) fn report_js(s: &mut Session, name: &str, out: Value) -> Result<Value> {
     if let Some(e) = out.get("error").filter(|e| !e.is_null()) {
         let line = e.get("line").and_then(Value::as_u64).map(|l| format!(" (line {l})")).unwrap_or_default();
         let msg = e.get("message").and_then(Value::as_str).unwrap_or("script error");
@@ -552,6 +552,13 @@ pub(crate) fn run_js_named(s: &mut Session, code: &str, name: &str) -> Result<Va
     report_js(s, name, out)
 }
 
+/// Run the code of the script file at `path` (its `#include`s and `$.fileName` use that path),
+/// reported under its file name `name` (Startup and Shutdown scripts).
+pub(crate) fn run_js_file(s: &mut Session, code: &str, path: &str, name: &str) -> Result<Value> {
+    let out = run_js(s, code, path, false)?;
+    report_js(s, name, out)
+}
+
 /// Run JavaScript through the session's scripting engine.
 fn run_js(s: &mut Session, code: &str, name: &str, console: bool) -> Result<Value> {
     let runner = s.script.ok_or_else(|| EngineError::Other("JavaScript scripting is not available in this build".into()))?;
@@ -594,6 +601,131 @@ pub(crate) struct Interpretation {
     preserve_rgb: Option<bool>,
     /// Start Timecode.
     start: Option<StartTimecode>,
+    /// Cineon Settings (DPX and Cineon footage).
+    cineon: CineonEdit,
+}
+
+/// Interpret Footage ▸ Cineon Settings parsed from command parameters (every field optional).
+#[derive(Clone, Debug, Default)]
+struct CineonEdit {
+    /// Logarithmic Conversion.
+    log: Option<bool>,
+    units: Option<CineonUnits>,
+    /// The units the Converted Black and White Points are given in (`pointUnits`, else `cineonUnits`,
+    /// else the footage's own Units).
+    point_units: Option<CineonUnits>,
+    converted_black: Option<f64>,
+    converted_white: Option<f64>,
+    /// 10 Bit Black and White Points.
+    black: Option<f64>,
+    white: Option<f64>,
+    gamma: Option<f64>,
+    rolloff: Option<f64>,
+}
+
+impl CineonEdit {
+    fn parse(p: &Value, cmd: &str) -> Result<CineonEdit> {
+        let units = |key: &str| -> Result<Option<CineonUnits>> {
+            match str_p(p, key) {
+                None => Ok(None),
+                Some(u) => CineonUnits::parse(u).map(Some).ok_or_else(|| bad(cmd, format!("{key}: 10bit|8bit|float, not `{u}`"))),
+            }
+        };
+        let num = |key: &str, lo: f64, hi: f64| -> Result<Option<f64>> {
+            match p.get(key) {
+                None | Some(Value::Null) => Ok(None),
+                Some(v) => v
+                    .as_f64()
+                    .filter(|x| x.is_finite() && (lo..=hi).contains(x))
+                    .map(Some)
+                    .ok_or_else(|| bad(cmd, format!("{key}: a number from {lo} to {hi}"))),
+            }
+        };
+        let units_now = units("cineonUnits")?;
+        Ok(CineonEdit {
+            log: b_p(p, "logConversion"),
+            units: units_now,
+            point_units: units("pointUnits")?.or(units_now),
+            // Range-checked once their units are known (`settings_for`).
+            converted_black: num("convertedBlack", f64::MIN, f64::MAX)?,
+            converted_white: num("convertedWhite", f64::MIN, f64::MAX)?,
+            black: num("tenBitBlack", 0.0, 1023.0)?,
+            white: num("tenBitWhite", 0.0, 1023.0)?,
+            gamma: num("currentGamma", 0.1, 10.0)?,
+            rolloff: num("highlightRolloff", 0.0, 100.0)?,
+        })
+    }
+
+    fn is_empty(&self) -> bool {
+        self.log.is_none()
+            && self.units.is_none()
+            && self.converted_black.is_none()
+            && self.converted_white.is_none()
+            && self.black.is_none()
+            && self.white.is_none()
+            && self.gamma.is_none()
+            && self.rolloff.is_none()
+    }
+
+    /// Footage `f`'s Cineon Settings after this edit; `None` when nothing changes them (no Cineon
+    /// parameters, or `f` is not a DPX or Cineon file).
+    fn settings_for(&self, f: &Footage, cmd: &str) -> Result<Option<CineonSettings>> {
+        if self.is_empty() || !f.is_cineon_file() {
+            return Ok(None);
+        }
+        let mut c = f.cineon;
+        let units = self.point_units.unwrap_or(c.units);
+        let point = |v: f64| -> Result<f32> {
+            let ten = units.to_ten_bit(v);
+            let max = units.from_ten_bit(f64::from(CineonSettings::MAX));
+            if (0.0..=f64::from(CineonSettings::MAX)).contains(&ten) {
+                Ok(ten as f32)
+            } else {
+                Err(bad(cmd, format!("converted points: 0 to {max} in {} units", units.label())))
+            }
+        };
+        if let Some(v) = self.converted_black {
+            c.converted_black = point(v)?;
+        }
+        if let Some(v) = self.converted_white {
+            c.converted_white = point(v)?;
+        }
+        if let Some(v) = self.log {
+            c.log_conversion = v;
+        }
+        if let Some(u) = self.units {
+            c.units = u;
+        }
+        if let Some(v) = self.black {
+            c.black = v as f32;
+        }
+        if let Some(v) = self.white {
+            c.white = v as f32;
+        }
+        if let Some(v) = self.gamma {
+            c.gamma = v as f32;
+        }
+        if let Some(v) = self.rolloff {
+            c.rolloff = v as f32;
+        }
+        if c.black >= c.white {
+            return Err(bad(cmd, "the 10 Bit Black Point must be below the 10 Bit White Point"));
+        }
+        Ok(Some(c))
+    }
+}
+
+/// Footage `f`'s Cineon Settings as commands report them (`null` for files they don't apply to).
+fn cineon_json(f: &Footage) -> Value {
+    if !f.is_cineon_file() {
+        return Value::Null;
+    }
+    let c = &f.cineon;
+    json!({
+        "logConversion": c.log_conversion, "units": c.units.id(),
+        "convertedBlack": c.units.from_ten_bit(f64::from(c.converted_black)), "convertedWhite": c.units.from_ten_bit(f64::from(c.converted_white)),
+        "tenBitBlack": c.black, "tenBitWhite": c.white, "currentGamma": c.gamma, "highlightRolloff": c.rolloff,
+    })
 }
 
 /// Interpret Footage ▸ Start Timecode.
@@ -687,9 +819,23 @@ impl Interpretation {
                 v.as_f64().filter(|x| x.is_finite() && (0.0..=StartTimecode::MAX as f64).contains(x)).map(|x| x.round() as i64).ok_or_else(start_err)?,
             )),
         };
+        it.cineon = CineonEdit::parse(p, cmd)?;
         Ok(it)
     }
 
+    /// Check the Cineon Settings this interpretation gives each of `footage`: an error names a
+    /// value out of range, or Cineon parameters when none of the footage is DPX or Cineon.
+    pub(crate) fn check<'a>(&self, footage: impl IntoIterator<Item = &'a Footage>, cmd: &str) -> Result<()> {
+        if self.cineon.is_empty() {
+            return Ok(());
+        }
+        let mut any = false;
+        for f in footage {
+            any |= self.cineon.settings_for(f, cmd)?.is_some();
+        }
+        if any { Ok(()) } else { Err(bad(cmd, "Cineon Settings apply to DPX and Cineon footage only")) }
+    }
+
     pub(crate) fn apply(&self, f: &mut Footage, guessed: Option<(AlphaMode, [f32; 3])>) {
         let before = f.frame_rate;
         self.apply_settings(f, guessed);
@@ -749,6 +895,10 @@ impl Interpretation {
         if let Some(v) = self.preserve_rgb {
             f.preserve_rgb = v;
         }
+        // Checked before the edit (`Interpretation::check`).
+        if let Ok(Some(c)) = self.cineon.settings_for(f, "file.interpretFootage") {
+            f.cineon = c;
+        }
         // After the frame rate: timecode is read at the footage's rate.
         if let Some(start) = self.start.as_ref().and_then(|t| t.frame(f.frame_rate)) {
             f.start_timecode = start;
@@ -795,6 +945,11 @@ fn interpret(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad("file.interpretFootage", "select footage"));
     }
     let it = Interpretation::parse(p, "file.interpretFootage")?;
+    let footage = items.iter().filter_map(|i| match s.project.item(*i).map(|x| &x.kind) {
+        Some(ItemKind::Footage(f)) => Some(f),
+        _ => None,
+    });
+    it.check(footage, "file.interpretFootage")?;
     let guesses: Vec<Option<(AlphaMode, [f32; 3])>> = items
         .iter()
         .map(|i| match (it.guess, s.project.item(*i).map(|x| &x.kind)) {
@@ -830,7 +985,7 @@ fn interpret(s: &mut Session, p: &Value) -> Result<Value> {
                 "item": i.0, "alpha": format!("{:?}", f.alpha), "matteColor": f.premul_color, "invertAlpha": f.invert_alpha,
                 "fields": f.fields.label(), "pixelAspect": f.pixel_aspect, "loop": f.loop_count, "frameRate": f.frame_rate.as_f64(),
                 "linearLight": f.linear_light, "preserveRgb": f.preserve_rgb, "startTimecode": f.timecode(0), "overrideStart": f.start_timecode.is_some(),
-                "frames": f.sequence_frames(),
+                "frames": f.sequence_frames(), "cineon": cineon_json(f),
             })),
             _ => None,
         })
@@ -861,6 +1016,9 @@ fn apply_interpretation(s: &mut Session, p: &Value) -> Result<Value> {
                 f.linear_light = src.linear_light;
                 f.preserve_rgb = src.preserve_rgb;
                 f.color_profile = src.color_profile;
+                if f.is_cineon_file() && src.is_cineon_file() {
+                    f.cineon = src.cineon;
+                }
                 if src.native_rate.is_some() {
                     if f.native_rate.is_none() {
                         f.native_rate = Some(f.frame_rate);
@@ -1090,7 +1248,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Main...",
             ["File", "Interpret Footage"],
             Some("Cmd+Alt+G"),
-            "{items?|item?, frameRate?: fps|\"file\", alpha?: straight|premultiplied|ignore|guess, guessAlpha?, matteColor?|premulColor?, invertAlpha?, loop?, pixelAspect?, fields?: off|upper|lower, colorProfile?: srgb|rec709|rec2020|p3|auto, linearLight?, preserveRgb? (the file's values unconverted), overrideStart?: bool (false: Use Source File Timecode), startTimecode?: timecode|frame (Override Start)}",
+            "{items?|item?, frameRate?: fps|\"file\", alpha?: straight|premultiplied|ignore|guess, guessAlpha?, matteColor?|premulColor?, invertAlpha?, loop?, pixelAspect?, fields?: off|upper|lower, colorProfile?: srgb|rec709|rec2020|p3|auto, linearLight?, preserveRgb? (the file's values unconverted), overrideStart?: bool (false: Use Source File Timecode), startTimecode?: timecode|frame (Override Start), logConversion? (Cineon Settings of DPX and Cineon files), cineonUnits?: 10bit|8bit|float, convertedBlack?, convertedWhite?, pointUnits?: 10bit|8bit|float (the units of convertedBlack and convertedWhite; default cineonUnits, else the footage's Units), tenBitBlack?, tenBitWhite? (0..1023), currentGamma? (0.1..10), highlightRolloff? (0..100)}",
             has_footage_selection,
             interpret
         ),

crates/engine/src/cmd/footage_panel.rs

@@ -56,6 +56,12 @@ pub fn timecode(item: Option<&effectcraft_project::Item>, fr: effectcraft_time::
     }
 }
 
+/// The frame the Footage panel shows: footage `f` at source time `t`, with its Cineon Settings
+/// applied.
+pub fn frame(s: &Session, item: ItemId, f: &effectcraft_project::Footage, t: Tick) -> Option<std::sync::Arc<effectcraft_raster::Image>> {
+    s.footage.frame(item, f, t).map(|img| effectcraft_render::cineon_frame(img, f))
+}
+
 fn source_time(s: &Session, p: &Value, item: ItemId) -> Option<Tick> {
     let (_, fr) = source_timing(s, item);
     if let Some(t) = f_p(p, "time") {

crates/engine/src/cmd/layer.rs

@@ -183,7 +183,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Add (Shape)",
             [],
             None,
-            "{layer?, kind: group|rect|ellipse|star|polygon|path|fill|stroke|gfill|gstroke|trim|repeater|round|offset|pucker|twist|zigzag|wiggle|merge|frontColor|bevelColor|sideColor|backColor, group?: uid|path} → {uid, path} (frontColor…backColor: the group's Front / Bevel / Side / Back item, which colours that surface of every extruded paint in the group in Advanced 3D)",
+            "{layer?, kind: group|rect|ellipse|star|polygon|path|fill|stroke|gfill|gstroke|trim|repeater|round|offset|pucker|twist|zigzag|wiggle|wiggler|merge|frontColor|bevelColor|sideColor|backColor, group?: uid|path} → {uid, path} (frontColor…backColor: the group's Front / Bevel / Side / Back item, which colours that surface of every extruded paint in the group in Advanced 3D)",
             has_layers,
             add_shape_item
         ),

crates/engine/src/cmd/layer/parent.rs

@@ -526,7 +526,7 @@ pub(super) fn set_parent(s: &mut Session, p: &Value) -> Result<Value> {
     let fixes = if compensate { parent_fixes(s, cid, &ids, parent) } else { vec![] };
     s.edit("Parent", None, |proj, _| {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.parent = parent;
             if let Some(f) = fixes.iter().find(|f| f.layer == l.id) {
                 f.apply(l);

crates/engine/src/cmd/layer/switches.rs

@@ -19,7 +19,7 @@ pub(super) fn set_switch(s: &mut Session, p: &Value) -> Result<Value> {
         let first = comp.layers.iter().find(|l| ids.contains(&l.id)).map(|l| switch_value(l, &name)).unwrap_or(Some(false));
         let Some(first) = first else { return Err(bad("layer.setSwitch", format!("unknown switch `{name}`"))) };
         let target = v.unwrap_or(!first);
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             set_switch_value(l, &name, target);
             last = target;
         }
@@ -55,7 +55,7 @@ fn set_switch_others(s: &mut Session, cid: ItemId, ids: &[LayerId], name: &str,
             alone &= on == (ids.contains(&l.id) == active);
         }
         let others = value.unwrap_or(alone == active);
-        for l in comp.layers.iter_mut().filter(|l| applies(l)) {
+        for l in comp.layers.iter_mut_where(|l| applies(l)) {
             let v = if ids.contains(&l.id) { active } else { others };
             set_switch_value(l, name, v);
         }
@@ -152,7 +152,7 @@ pub(super) fn set_comment(s: &mut Session, p: &Value) -> Result<Value> {
     let text = str_p(p, "comment").ok_or_else(|| bad("layer.setComment", "missing `comment`"))?.to_string();
     s.edit("Layer Comment", None, |proj, _| {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.comment = text.clone();
         }
         Ok(())
@@ -169,7 +169,7 @@ pub(super) fn blend(s: &mut Session, p: &Value) -> Result<Value> {
     }
     s.edit("Blending Mode", None, |proj, _| {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.blend_mode = match mode {
                 Some(m) => m,
                 None if step > 0 => l.blend_mode.next(),

crates/engine/src/cmd/layer/timing.rs

@@ -18,7 +18,7 @@ pub(super) fn timing(s: &mut Session, p: &Value) -> Result<Value> {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
         let fd = comp.frame_duration();
         let comp_dur = comp.duration;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             let shift = |l: &mut Layer, d: Tick| {
                 l.start_time += d;
                 l.in_point += d;
@@ -161,14 +161,14 @@ pub(super) fn arrange(s: &mut Session, p: &Value) -> Result<Value> {
                 for i in 1..n {
                     if picked(&comp.layers[i]) && !picked(&comp.layers[i - 1]) {
                         let run_end = (i..n).find(|j| !picked(&comp.layers[*j])).unwrap_or(n);
-                        comp.layers[i - 1..run_end].rotate_left(1);
+                        comp.layers.rotate_range_left(i - 1..run_end, 1);
                     }
                 }
             } else {
                 for i in (0..n.saturating_sub(1)).rev() {
                     if picked(&comp.layers[i]) && !picked(&comp.layers[i + 1]) {
                         let run_start = (0..=i).rev().find(|j| !picked(&comp.layers[*j])).map_or(0, |j| j + 1);
-                        comp.layers[run_start..=i + 1].rotate_right(1);
+                        comp.layers.rotate_range_right(run_start..=i + 1, 1);
                     }
                 }
             }

crates/engine/src/cmd/layer_menu.rs

@@ -61,7 +61,7 @@ fn quality(s: &mut Session, p: &Value) -> Result<Value> {
         q => return Err(bad("layer.quality", format!("quality must be best|draft|wireframe, not `{q}`"))),
     };
     s.edit("Layer Quality", None, |proj, _| {
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.switches.quality = q;
         }
         Ok(())
@@ -84,7 +84,7 @@ fn sampling(s: &mut Session, p: &Value) -> Result<Value> {
         q => q,
     };
     s.edit("Layer Sampling", None, |proj, _| {
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.switches.sampling = q;
         }
         Ok(())
@@ -101,7 +101,7 @@ fn frame_blending(s: &mut Session, p: &Value) -> Result<Value> {
         m => return Err(bad("layer.frameBlending", format!("mode must be off|frameMix|pixelMotion, not `{m}`"))),
     };
     s.edit("Frame Blending", None, |proj, _| {
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.switches.frame_blend = m;
         }
         Ok(())
@@ -116,7 +116,7 @@ fn hide_other_video(s: &mut Session, p: &Value) -> Result<Value> {
     s.edit("Hide Other Video", None, |proj, _| {
         // Every layer has a Video switch (nulls, cameras and lights included, as the Timeline's
         // eye cell shows): the selection stays shown.
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| !ids.contains(&l.id)) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| !ids.contains(&l.id)) {
             l.switches.video = false;
         }
         Ok(())
@@ -130,7 +130,7 @@ fn show_all_video(s: &mut Session, p: &Value) -> Result<Value> {
         let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
         // Track mattes stay hidden (their video switch is off by design).
         let mattes: Vec<LayerId> = c.layers.iter().filter_map(|l| l.track_matte.map(|m| m.layer)).collect();
-        for l in c.layers.iter_mut().filter(|l| !mattes.contains(&l.id)) {
+        for l in c.layers.iter_mut_where(|l| !mattes.contains(&l.id)) {
             l.switches.video = true;
         }
         Ok(())
@@ -154,7 +154,7 @@ fn expressions(s: &mut Session, p: &Value) -> Result<Value> {
     let on = b_p(p, "enabled").unwrap_or(true);
     let n = s.edit(if on { "Enable Expressions" } else { "Disable Expressions" }, None, |proj, _| {
         let mut n = 0;
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.props.walk_mut(&mut |pr| {
                 if let Some(e) = &mut pr.expr {
                     e.enabled = on;
@@ -586,7 +586,7 @@ fn markers_lock(s: &mut Session, p: &Value) -> Result<Value> {
     let r = s.edit("Lock Markers", None, |proj, _| {
         let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
         let target = v.unwrap_or_else(|| !c.layers.iter().find(|l| ids.contains(&l.id)).is_some_and(|l| l.markers_locked));
-        for l in c.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in c.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.markers_locked = target;
         }
         Ok(target)
@@ -597,7 +597,7 @@ fn markers_lock(s: &mut Session, p: &Value) -> Result<Value> {
 fn delete_all_markers(s: &mut Session, p: &Value) -> Result<Value> {
     let (cid, ids) = layers_p(s, p)?;
     s.edit("Delete All Markers", None, |proj, _| {
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id) && !l.markers_locked) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| ids.contains(&l.id) && !l.markers_locked) {
             l.markers.clear();
         }
         Ok(())

crates/engine/src/cmd/layer_time.rs

@@ -34,7 +34,7 @@ fn time_stretch(s: &mut Session, p: &Value) -> Result<Value> {
     let fd = comp_rate.frame_duration();
     s.edit(if reverse { "Time-Reverse Layer" } else { "Time Stretch" }, None, |proj, _| {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             let old = l.stretch;
             if reverse {
                 // Keep the in/out points; play the visible span backwards.
@@ -109,7 +109,7 @@ fn enable_time_remap(s: &mut Session, p: &Value) -> Result<Value> {
         let mut next = proj.next_id;
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
         let mut on = false;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id) && remappable(l)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id) && remappable(l)) {
             let has = l.props.get("timeRemap").is_some();
             let target = want.unwrap_or(!has);
             on |= target;

crates/engine/src/cmd/model3d.rs

@@ -64,6 +64,12 @@ fn comp_renderer(s: &mut Session, p: &Value) -> Result<Value> {
     if r == Renderer::Classic3D && s.project.comp(cid).is_some_and(|c| c.layers.iter().any(|l| l.source.is_model())) {
         s.toast("Classic 3D doesn't draw 3D model layers: they show with the Advanced 3D renderer");
     }
+    if r == Renderer::Classic3D {
+        let env = |l: &Layer| matches!(l.source, LayerSource::Light { kind: effectcraft_project::LightKind::Environment });
+        if s.project.comp(cid).is_some_and(|c| c.layers.iter().any(env)) {
+            s.toast("Classic 3D doesn't light Environment light layers: they light with the Advanced 3D renderer");
+        }
+    }
     Ok(json!({"renderer": renderer_id(r)}))
 }
 
@@ -77,7 +83,7 @@ fn renderer_id(r: Renderer) -> &'static str {
 /// Only the Advanced 3D renderer draws model and primitive layers, so adding one switches a
 /// Classic 3D comp to it, like After Effects (inside the adding edit: one undo step). Whether
 /// the renderer changed.
-fn use_advanced_3d(proj: &mut effectcraft_project::Project, cid: ItemId) -> Result<bool> {
+pub(crate) fn use_advanced_3d(proj: &mut effectcraft_project::Project, cid: ItemId) -> Result<bool> {
     let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
     let switched = c.renderer != Renderer::Advanced3D;
     c.renderer = Renderer::Advanced3D;
@@ -86,10 +92,10 @@ fn use_advanced_3d(proj: &mut effectcraft_project::Project, cid: ItemId) -> Resu
 }
 
 /// Tell the user when [`use_advanced_3d`] changed the comp's renderer.
-fn report_switch(s: &mut Session, cid: ItemId, switched: bool) {
+pub(crate) fn report_switch(s: &mut Session, cid: ItemId, switched: bool, why: &str) {
     if switched {
         let name = s.project.item(cid).map_or("the composition", |i| i.name.as_str()).to_string();
-        s.toast(format!("\"{name}\" now uses the Advanced 3D renderer, which draws 3D models"));
+        s.toast(format!("\"{name}\" now uses the Advanced 3D renderer, {why}"));
     }
 }
 
@@ -156,7 +162,7 @@ pub(crate) fn new_model(s: &mut Session, p: &Value) -> Result<Value> {
         let id = insert_layer_at(proj, st, cid, l, index)?;
         Ok((id, use_advanced_3d(proj, cid)?))
     })?;
-    report_switch(s, cid, switched);
+    report_switch(s, cid, switched, "which draws 3D models");
     Ok(json!({"layer": id.0, "item": item.0, "advanced3d": true}))
 }
 
@@ -226,7 +232,7 @@ fn new_primitive(s: &mut Session, p: &Value) -> Result<Value> {
         let id = insert_layer(proj, st, cid, l)?;
         Ok((id, use_advanced_3d(proj, cid)?))
     })?;
-    report_switch(s, cid, switched);
+    report_switch(s, cid, switched, "which draws 3D models");
     Ok(json!({"layer": id.0, "kind": kind.label(), "advanced3d": true}))
 }
 

crates/engine/src/cmd/paths.rs

@@ -360,7 +360,7 @@ fn free_transform(s: &mut Session, p: &Value) -> Result<Value> {
 
 const SHAPE_ITEMS: &[&str] = &[
     "group", "rect", "ellipse", "star", "path", "fill", "stroke", "gfill", "gstroke", "trim", "repeater", "round", "offset", "pucker", "twist", "zigzag",
-    "wiggle", "merge", "front", "bevel", "side", "back",
+    "wiggle", "wiggler", "merge", "front", "bevel", "side", "back",
 ];
 
 /// Selected shape items (contents entries) of shape layers: (layer, uid).

crates/engine/src/cmd/prop.rs

@@ -1189,6 +1189,15 @@ fn toggle_hold(s: &mut Session, _: &Value) -> Result<Value> {
     })
 }
 
+fn set_muted(s: &mut Session, p: &Value) -> Result<Value> {
+    let muted = b_p(p, "muted").unwrap_or(true);
+    let label = if muted { "Mute Keyframes" } else { "Unmute Keyframes" };
+    edit_keys(s, label, None, move |keys, i, _| {
+        keys[i].muted = muted;
+        false
+    })
+}
+
 /// A number or a per-dimension array of numbers.
 fn nums_p(p: &Value, k: &str, scale: f64) -> Option<Vec<f64>> {
     match p.get(k)? {
@@ -1381,6 +1390,7 @@ pub fn specs() -> Vec<CommandSpec> {
             &json!({"which": "out"})
         )),
         cmd!("keys.toggleHold", "Toggle Hold Keyframe", ["Animation"], Some("Cmd+Alt+H"), "{}", has_keys, toggle_hold),
+        cmd!("keys.setMuted", "Mute Keyframes", ["Animation"], None, "{muted?: bool (default true)}", has_keys, set_muted),
         cmd!(
             "keys.interpolation",
             "Keyframe Interpolation...",

crates/engine/src/cmd/proxy.rs

@@ -117,6 +117,7 @@ fn interpret_proxy(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad(C, "the selected items have no proxy"));
     }
     let it = super::file_more::Interpretation::parse(p, C)?;
+    it.check(items.iter().filter_map(|i| s.project.item(*i).and_then(|x| x.proxy.as_ref()).map(|px| &px.footage)), C)?;
     let guesses: Vec<_> = items
         .iter()
         .map(|i| {
@@ -229,7 +230,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Proxy...",
             ["File", "Interpret Footage"],
             None,
-            "{items?|item?, alpha?, guessAlpha?, matteColor?|premulColor?, invertAlpha?, frameRate?, loop?, pixelAspect?, fields?, colorProfile?, linearLight?, preserveRgb?, overrideStart?, startTimecode? (as file.interpretFootage)}",
+            "{items?|item?, alpha?, guessAlpha?, matteColor?|premulColor?, invertAlpha?, frameRate?, loop?, pixelAspect?, fields?, colorProfile?, linearLight?, preserveRgb?, overrideStart?, startTimecode? (as file.interpretFootage), logConversion?, cineonUnits?, convertedBlack?, convertedWhite?, pointUnits?, tenBitBlack?, tenBitWhite?, currentGamma?, highlightRolloff? (Cineon Settings of DPX and Cineon proxies)}",
             has_proxy,
             interpret_proxy
         ),

crates/engine/src/cmd/rig3d.rs

@@ -277,7 +277,7 @@ fn stereo_rig(s: &mut Session, p: &Value) -> Result<Value> {
             set_expr(&mut cam, "cameraOptions/zoom", ze);
             cam.auto_orient = AutoOrient::TowardsPointOfInterest;
             let comp = proj.comp_mut(eid).ok_or(EngineError::NoComp)?;
-            comp.layers = vec![cam, nest];
+            comp.layers = vec![cam, nest].into();
             eye_comps.push(eid);
         }
         // The output comp: both eyes through 3D Glasses.
@@ -300,7 +300,7 @@ fn stereo_rig(s: &mut Session, p: &Value) -> Result<Value> {
             fxg.children.push(g.into());
         }
         let (lid, rid) = (left.id, right.id);
-        proj.comp_mut(oid).ok_or(EngineError::NoComp)?.layers = vec![left, right];
+        proj.comp_mut(oid).ok_or(EngineError::NoComp)?.layers = vec![left, right].into();
         st.project_selection = vec![oid];
         Ok(json!({
             "controls": ctl_id.0,

crates/engine/src/cmd/scripts.rs

@@ -7,6 +7,9 @@
 //!   panels appear at the bottom of the Window menu and open as dockable panels
 //!   (`window.scriptPanel`), running with `this` = the panel as in After Effects. A subfolder of
 //!   either folder (one level) is a submenu named after it; its scripts are named `Folder/File.jsx`.
+//! * **Startup and Shutdown scripts** in `Scripts/Startup/` and `Scripts/Shutdown/` run by
+//!   themselves, in alphabetical order: at launch (`file.runStartupScripts`) and as EffectCraft
+//!   quits, after the project is closed (`file.runShutdownScripts`).
 //! * **ScriptUI windows** (`scriptui.*`): list the open script windows, read their control
 //!   trees, click buttons and set values like a user, close them (see [`crate::scriptui`]).
 //! * **Script settings** (`script.settings.*`): After Effects' `app.settings`, string values by
@@ -23,6 +26,18 @@ use crate::{EngineError, Event, Result, Session, cmd, scriptui};
 /// The settings-store folders of installed scripts.
 pub const SCRIPTS_DIR: &str = "Scripts";
 pub const PANELS_DIR: &str = "Scripts/ScriptUI Panels";
+/// The settings-store folders whose scripts run at launch and as EffectCraft quits.
+pub const STARTUP_DIR: &str = "Scripts/Startup";
+pub const SHUTDOWN_DIR: &str = "Scripts/Shutdown";
+/// Commands that run script files or script code (a ScriptUI panel runs its script when it
+/// opens). Scripts and batches can't run them, and confined automation sessions refuse them.
+pub const RUNS_SCRIPTS: &[&str] =
+    &["script.run", "file.runScript", "file.runStartupScripts", "file.runShutdownScripts", "window.scriptPanel", "window.restoreScriptPanels"];
+/// Largest script file the Startup and Shutdown folders run (bytes), as `#include` and
+/// `$.evalFile` allow.
+const MAX_SCRIPT_BYTES: usize = 16 << 20;
+/// Modal dialogs a Shutdown script may open one after another; each closes as if canceled.
+const MAX_SHUTDOWN_DIALOGS: usize = 64;
 /// [`PANELS_DIR`]'s name in [`SCRIPTS_DIR`]: it holds the panels, so it is not a folder of scripts.
 const PANELS_FOLDER: &str = "ScriptUI Panels";
 /// Subfolders of Scripts that hold scripts the app runs itself (panels; launch and quit, as in
@@ -221,6 +236,7 @@ fn install(s: &mut Session, p: &Value, panel: bool) -> Result<Value> {
     let cfg = s.config.clone().ok_or_else(|| EngineError::Other("this session has no settings folder to install scripts into".into()))?;
     let dir = if panel { PANELS_DIR } else { SCRIPTS_DIR };
     cfg.write(&format!("{dir}/{name}"), &code).map_err(|e| EngineError::Other(format!("cannot install {name}: {e}")))?;
+    s.scripts_changed();
     // After Effects asks for a restart; our menus pick it up at once.
     s.toast(if panel {
         format!("Installed ScriptUI panel {name}: find it at the bottom of the Window menu")
@@ -256,6 +272,7 @@ fn uninstall(s: &mut Session, p: &Value) -> Result<Value> {
             removed = true;
         }
     }
+    s.scripts_changed();
     if removed { Ok(json!({"removed": name})) } else { Err(bad(c, format!("`{name}` is not installed"))) }
 }
 
@@ -337,6 +354,85 @@ fn restore_panels(s: &mut Session, _: &Value) -> Result<Value> {
     Ok(json!({"opened": opened, "failed": failed}))
 }
 
+/// Run the scripts in `dir` of the settings store one after another, in alphabetical order (case
+/// ignored), as After Effects runs its Startup and Shutdown folders. A script that fails is
+/// reported in a toast and the log and listed in `failed`; the next one still runs. A script waiting in a
+/// modal dialog is listed in `waiting` and goes on when the dialog closes; the next one runs
+/// meanwhile. With `quitting`, no window is left to show a dialog in, so each dialog closes as
+/// if canceled (`show()` returns 2) and the script runs on.
+fn run_folder(s: &mut Session, dir: &str, quitting: bool) -> Value {
+    let mut names: Vec<String> = s.config.as_ref().map(|c| c.list(dir)).unwrap_or_default().into_iter().filter(|n| is_script(n) && is_script_name(n)).collect();
+    names.sort_by(|a, b| a.to_lowercase().cmp(&b.to_lowercase()).then_with(|| a.cmp(b)));
+    let (mut ran, mut waiting, mut failed) = (vec![], vec![], vec![]);
+    for name in names {
+        let code = match s.config.as_ref().map(|c| c.read_bounded(&format!("{dir}/{name}"), MAX_SCRIPT_BYTES)) {
+            Some(Ok(Some(code))) => code,
+            read => {
+                let why = match read {
+                    Some(Err(e)) => format!(": {e}"),
+                    _ => String::new(),
+                };
+                let error = format!("{name}: cannot read the script{why}");
+                log::warn!("{dir}: {error}");
+                s.events.push(Event::Toast { message: error.clone(), error: true });
+                failed.push(json!({"name": name, "error": error}));
+                continue;
+            }
+        };
+        let is_waiting = |r: &Result<Value>| r.as_ref().is_ok_and(|v| v.get("waiting").and_then(Value::as_bool) == Some(true));
+        // In a settings folder on disk, the script runs as its file, so `#include`, `$.fileName`
+        // and `$.evalFile` find the files beside it.
+        let path = s.config.as_ref().and_then(|c| c.dir()).map(|d| d.join(dir).join(&name).to_string_lossy().into_owned()).unwrap_or_else(|| name.clone());
+        // Windows open before this script runs belong to other scripts, perhaps of the same name.
+        let before: Vec<u32> = s.script_ui.windows.iter().map(|w| w.id).collect();
+        let hosts_before = s.script_ui.task_hosts.clone();
+        let mut r = super::file_more::run_js_file(s, &code, &path, &name);
+        if !quitting {
+            // The Startup script's context: the one that scheduled tasks or holds the windows it
+            // opened (a task scheduled after its dialog closes runs there too).
+            let tasks = s.script_ui.task_hosts.iter().filter(|h| !hosts_before.contains(h)).copied();
+            let windows = s.script_ui.windows.iter().filter(|w| !before.contains(&w.id)).map(|w| w.host);
+            let hosts: Vec<u32> = tasks.chain(windows).collect();
+            for h in hosts {
+                if !s.script_ui.startup_hosts.contains(&h) {
+                    s.script_ui.startup_hosts.push(h);
+                }
+            }
+        }
+        let mut closed = 0;
+        while quitting && closed < MAX_SHUTDOWN_DIALOGS && is_waiting(&r) {
+            let Some(id) = s.script_ui.windows.iter().rev().find(|w| w.modal && w.script == path && !before.contains(&w.id)).map(|w| w.id) else { break };
+            // report_js reports an error the script throws after its dialog closes, as it does for an
+            // error in the script's first run.
+            r = scriptui::close(s, &json!({"window": id})).and_then(|out| super::file_more::report_js(s, &name, out));
+            closed += 1;
+        }
+        match r {
+            Ok(_) if is_waiting(&r) => waiting.push(name),
+            Ok(_) => ran.push(name),
+            Err(e) => {
+                // Also in the log: no frame draws a Shutdown script's toast.
+                log::warn!("{dir}: {e}");
+                failed.push(json!({"name": name, "error": e.to_string()}));
+            }
+        }
+    }
+    json!({"ran": ran, "waiting": waiting, "failed": failed})
+}
+
+/// `file.runStartupScripts`: run the scripts in `Scripts/Startup` (frontends call it once at
+/// launch, before a project opens).
+fn run_startup(s: &mut Session, _: &Value) -> Result<Value> {
+    Ok(run_folder(s, STARTUP_DIR, false))
+}
+
+/// `file.runShutdownScripts`: close the project, then run the scripts in `Scripts/Shutdown`
+/// (frontends call it as the app quits, after the unsaved-changes prompt).
+fn run_shutdown(s: &mut Session, _: &Value) -> Result<Value> {
+    s.replace_project(effectcraft_project::Project::default(), None);
+    Ok(run_folder(s, SHUTDOWN_DIR, true))
+}
+
 /// Window ▸ `<ScriptUI panel>`: run the panel script (or bring its panel forward).
 fn open_panel(s: &mut Session, p: &Value) -> Result<Value> {
     let c = "window.scriptPanel";
@@ -414,6 +510,24 @@ pub fn specs() -> Vec<CommandSpec> {
             always,
             restore_panels
         ),
+        cmd!(
+            "file.runStartupScripts",
+            "Run Startup Scripts",
+            [],
+            None,
+            "{} → runs the scripts in Scripts/Startup in alphabetical order (frontends call it at launch) → {ran: [name], waiting: [name] (in a modal dialog), failed: [{name, error}]}",
+            always,
+            run_startup
+        ),
+        cmd!(
+            "file.runShutdownScripts",
+            "Run Shutdown Scripts",
+            [],
+            None,
+            "{} → closes the project, then runs the scripts in Scripts/Shutdown in alphabetical order (frontends call it as the app quits; their modal dialogs close as if canceled) → {ran: [name], waiting: [name], failed: [{name, error}]}",
+            always,
+            run_shutdown
+        ),
         crate::query!("script.settings.get", "Get Script Setting", "{section, key} → {have, value} (app.settings.haveSetting / getSetting)", settings_get),
         cmd!(
             "script.settings.save",
@@ -463,7 +577,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Mouse Event on Script Window Control",
             [],
             None,
-            "{window?, widget, type: mousedown | mouseup | mousemove | mouseover | mouseout | click (default), x?, y? (relative to the control; default its centre), button? (0 left, 1 middle, 2 right), detail? (click count), screenX?, screenY?, altKey?, ctrlKey?, metaKey?, shiftKey?} → the script's addEventListener listeners on the control and its containers receive a MouseEvent",
+            "{window?, widget, type: mousedown | mouseup | mousemove | mouseover | mouseout | click (default), x?, y? (relative to the control; default its centre), button? (0 left, 1 middle, 2 right), buttons? (held: 1 left, 2 right, 4 middle), detail? (click count), screenX?, screenY?, altKey?, ctrlKey?, metaKey?, shiftKey?} → the script's addEventListener listeners on the control and its containers receive a MouseEvent",
             always,
             scriptui::mouse
         ),
@@ -948,4 +1062,64 @@ mod tests {
         assert!(bad_params(&s.execute("file.uninstallScript", json!({"name": "Hello.jsx"}))), "no longer installed");
         let _ = std::fs::remove_dir_all(&root);
     }
+
+    /// Edit ▸ Keyboard Shortcuts lists the scripts File ▸ Scripts lists (not ScriptUI panels),
+    /// as soon as one is installed and until it is uninstalled; a key given to one is saved with
+    /// the preset.
+    #[test]
+    fn file_scripts_entries_take_keyboard_shortcuts() {
+        use crate::shortcuts::{Keymaps, SHORTCUTS_FILE, binding_key};
+        let (mut s, root) = session_in_tmp("shortcuts");
+        let (script, panel) = (root.join("Hello.jsx"), root.join("Hello Panel.jsx"));
+        std::fs::write(&script, "hello").unwrap();
+        std::fs::write(&panel, "panel").unwrap();
+        let listed = |s: &Session, name: &str| {
+            s.shortcuts().find(&binding_key("file.runScript", &json!({"name": name}))).map(|b| (b.label.clone(), b.path.join(" ▸ "), b.defaults.clone()))
+        };
+        assert_eq!(listed(&s, "Rename Layers.jsx"), Some(("Rename Layers.jsx".into(), "File ▸ Scripts".into(), vec![])), "the bundled samples");
+        assert_eq!(listed(&s, "Hello.jsx"), None);
+        s.execute("file.installScript", json!({"path": script.to_string_lossy()})).unwrap();
+        s.execute("file.installScriptUIPanel", json!({"path": panel.to_string_lossy()})).unwrap();
+        assert_eq!(listed(&s, "Hello.jsx"), Some(("Hello.jsx".into(), "File ▸ Scripts".into(), vec![])));
+        assert_eq!(listed(&s, "Hello Panel.jsx"), None, "panels are in the Window menu");
+        let r = s.execute("shortcuts.set", json!({"command": "file.runScript", "params": {"name": "Hello.jsx"}, "keys": "Cmd+Alt+Shift+F7"})).unwrap();
+        let key = binding_key("file.runScript", &json!({"name": "Hello.jsx"}));
+        assert_eq!((&r["command"], &r["keys"]), (&json!(key), &json!(["Cmd+Alt+Shift+F7"])), "{r}");
+        assert_eq!(s.shortcuts().shortcut_of("file.runScript", &json!({"name": "Hello.jsx"})), Some("Cmd+Alt+Shift+F7"));
+        let saved = Keymaps::from_json(&std::fs::read_to_string(root.join("settings").join(SHORTCUTS_FILE)).unwrap());
+        assert_eq!(saved.active_preset().and_then(|p| p.overrides.get(&key)), Some(&vec!["Cmd+Alt+Shift+F7".to_string()]));
+        s.execute("file.uninstallScript", json!({"name": "Hello.jsx"})).unwrap();
+        assert_eq!(listed(&s, "Hello.jsx"), None);
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    /// `shortcuts.list` and `shortcuts.set` see a script copied into the Scripts folder by hand
+    /// after the shortcut table was built; a script the folder doesn't hold (never there, or
+    /// removed by hand) can't take a key, and Run Script File… keeps its own keys.
+    #[test]
+    fn shortcut_commands_find_scripts_copied_into_the_folder() {
+        let (mut s, root) = session_in_tmp("copied");
+        assert!(s.shortcuts().find("file.runScript").is_some(), "the table is built");
+        std::fs::create_dir_all(root.join("settings").join(SCRIPTS_DIR)).unwrap();
+        std::fs::write(root.join("settings").join(SCRIPTS_DIR).join("Copied.jsx"), "copied").unwrap();
+        let list = s.execute("shortcuts.list", json!({"query": "copied.jsx"})).unwrap();
+        assert_eq!(list["count"], 1, "{list}");
+        let r = s.execute("shortcuts.set", json!({"command": "file.runScript", "params": {"name": "Copied.jsx"}, "keys": "Cmd+Alt+Shift+F7"})).unwrap();
+        assert_eq!(r["command"], r#"file.runScript {"name":"Copied.jsx"}"#, "{r}");
+        let r = s.execute("shortcuts.set", json!({"command": "file.runScript", "params": {"name": "Missing.jsx"}, "keys": "Cmd+Alt+Shift+F8"}));
+        assert!(bad_params(&r), "{r:?}");
+        // The binding-key form finds a script copied in since the last lookup, too.
+        std::fs::write(root.join("settings").join(SCRIPTS_DIR).join("Second.jsx"), "second").unwrap();
+        let r = s.execute("shortcuts.set", json!({"command": r#"file.runScript {"name":"Second.jsx"}"#, "keys": "Cmd+Alt+Shift+F10"})).unwrap();
+        assert_eq!(r["command"], r#"file.runScript {"name":"Second.jsx"}"#, "{r}");
+        // Removed by hand: no longer in the folder.
+        std::fs::remove_file(root.join("settings").join(SCRIPTS_DIR).join("Copied.jsx")).unwrap();
+        std::fs::remove_file(root.join("settings").join(SCRIPTS_DIR).join("Second.jsx")).unwrap();
+        let r = s.execute("shortcuts.set", json!({"command": r#"file.runScript {"name":"Second.jsx"}"#, "keys": "Cmd+Alt+Shift+F11"}));
+        assert!(bad_params(&r), "{r:?}");
+        let r = s.execute("shortcuts.set", json!({"command": "file.runScript", "params": {"name": "Copied.jsx"}, "keys": "Cmd+Alt+Shift+F9"}));
+        assert!(bad_params(&r), "{r:?}");
+        assert_eq!(s.shortcuts().shortcut_of("file.runScript", &Value::Null), None, "Run Script File… has no key");
+        let _ = std::fs::remove_dir_all(&root);
+    }
 }

crates/engine/src/cmd/settings.rs

@@ -73,13 +73,21 @@ fn prefs_pages(_: &mut Session, _: &Value) -> Result<Value> {
 
 // ---------------------------------------------------------------- shortcuts
 
-/// The bindable named by `command` (+ `params`), or by a binding key (`app.settings {...}`).
-fn bindable(s: &Session, p: &Value, cmd: &str) -> Result<crate::shortcuts::Bindable> {
+/// The bindable named by `command` (+ `params`), or by a binding key (`app.settings {...}`). A
+/// File ▸ Scripts entry (`file.runScript {"name": …}`) is looked up in File ▸ Scripts' list as it
+/// is now (the Scripts folder and the bundled scripts), and a script it doesn't list is an error,
+/// not Run Script File….
+fn bindable(s: &mut Session, p: &Value, cmd: &str) -> Result<crate::shortcuts::Bindable> {
     let c = str_p(p, "command").ok_or_else(|| bad(cmd, "missing `command`"))?;
     let params = p.get("params").cloned().unwrap_or(Value::Null);
-    let t = s.shortcuts();
     let key = binding_key(c, &params);
-    t.find(&key).or_else(|| t.find(c)).cloned().ok_or_else(|| bad(cmd, format!("`{key}` can't have a shortcut (see shortcuts.list)")))
+    let script = (c == "file.runScript" && params.get("name").is_some()) || c.starts_with("file.runScript {");
+    if script {
+        s.scripts_changed();
+    }
+    let t = s.shortcuts();
+    let found = if script { t.find(&key) } else { t.find(&key).or_else(|| t.find(c)) };
+    found.cloned().ok_or_else(|| bad(cmd, format!("`{key}` can't have a shortcut (see shortcuts.list)")))
 }
 
 fn keys_param(p: &Value, cmd: &str) -> Result<Vec<String>> {
@@ -93,6 +101,8 @@ fn keys_param(p: &Value, cmd: &str) -> Result<Vec<String>> {
 }
 
 fn sc_list(s: &mut Session, p: &Value) -> Result<Value> {
+    // Scripts copied into the Scripts folder since the table was built are listed too.
+    s.scripts_changed();
     let q = str_p(p, "query").unwrap_or("").to_lowercase();
     let assigned = p.get("assigned").and_then(Value::as_bool).unwrap_or(false);
     let keys_q = str_p(p, "keys").and_then(normalize);

crates/engine/src/cmd/three_d.rs

@@ -12,6 +12,7 @@ use effectcraft_time::Tick;
 use serde_json::{Value, json};
 
 use super::layer::{color_p, insert_layer};
+use super::model3d::{report_switch, use_advanced_3d};
 use super::{CommandSpec, b_p, bad, comp_id, f_p, has_comp, layer_mut, layer_p, merge_p, str_p, time_p};
 use crate::{EngineError, Result, Session, cmd, query};
 
@@ -227,12 +228,17 @@ fn new_light(s: &mut Session, p: &Value) -> Result<Value> {
     };
     let name = str_p(p, "name").unwrap_or("Light 1").to_string();
     let t = time_p(s, p, Some(&comp));
-    let id = s.edit("New Light", None, |proj, st| {
+    // Only the Advanced 3D renderer lights with Environment lights, so adding one switches a
+    // Classic 3D comp to it, like After Effects (inside the adding edit: one undo step).
+    let env = kind == LightKind::Environment;
+    let (id, switched) = s.edit("New Light", None, |proj, st| {
         let mut l = build::layer(proj, &comp, &name, LayerSource::Light { kind }, (comp.width, comp.height), None);
         apply_light(&mut l, p, t, "layer.newLight")?;
-        insert_layer(proj, st, cid, l)
+        let id = insert_layer(proj, st, cid, l)?;
+        Ok((id, if env { use_advanced_3d(proj, cid)? } else { false }))
     })?;
-    Ok(json!({"layer": id.0}))
+    report_switch(s, cid, switched, "which Environment lights need to light the scene");
+    Ok(json!({"layer": id.0, "advanced3d": env}))
 }
 
 fn light_settings(s: &mut Session, p: &Value) -> Result<Value> {
@@ -248,7 +254,7 @@ fn light_settings(s: &mut Session, p: &Value) -> Result<Value> {
         ),
         None => None,
     };
-    s.edit("Light Settings", None, |proj, _| {
+    let switched = s.edit("Light Settings", None, |proj, _| {
         let old = proj.comp(cid).and_then(|c| c.layer(lid)).cloned().ok_or(EngineError::NoComp)?;
         let mut l = old.clone();
         if let Some(k) = kind
@@ -288,9 +294,14 @@ fn light_settings(s: &mut Session, p: &Value) -> Result<Value> {
             l.name = n.clone();
         }
         apply_light(&mut l, p, t, "layer.lightSettings")?;
+        // A light that becomes an Environment light switches a Classic 3D comp to Advanced 3D,
+        // like adding one does; editing one that already is leaves the renderer to the user.
+        let was_env = matches!(old.source, LayerSource::Light { kind: LightKind::Environment });
+        let is_env = matches!(l.source, LayerSource::Light { kind: LightKind::Environment });
         *layer_mut(proj, cid, lid)? = l;
-        Ok(())
+        Ok(if !was_env && is_env { use_advanced_3d(proj, cid)? } else { false })
     })?;
+    report_switch(s, cid, switched, "which Environment lights need to light the scene");
     Ok(Value::Null)
 }
 
@@ -533,7 +544,7 @@ fn auto_orient(s: &mut Session, p: &Value) -> Result<Value> {
     };
     s.edit("Auto-Orient", None, |proj, _| {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             let rig = l.is_camera() || l.is_light();
             let ok = match mode {
                 AutoOrient::Off | AutoOrient::AlongPath => true,
@@ -683,7 +694,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Light...",
             ["Layer", "New"],
             Some("Cmd+Alt+Shift+L"),
-            "{kind?: Parallel|Spot|Point|Ambient|Environment (default Spot; Environment lights and reflects from an equirectangular image layer: prop.set its lightOptions/source to that layer's id, or leave it empty for the comp's Environment Layer, see layer.environment), name?, color?, intensity?, coneAngle?, coneFeather?, falloff?: None|Smooth|Inverse Square Clamped, radius?, falloffDistance?, castsShadows?, shadowDarkness?, shadowDiffusion?, position? [x,y,z], poi? [x,y,z]}",
+            "{kind?: Parallel|Spot|Point|Ambient|Environment (default Spot; Environment lights and reflects from an equirectangular image layer: prop.set its lightOptions/source to that layer's id, or leave it empty for the comp's Environment Layer or a flat default environment of its colour and intensity, see layer.environment; an Environment light switches a Classic 3D comp to Advanced 3D), name?, color?, intensity?, coneAngle?, coneFeather?, falloff?: None|Smooth|Inverse Square Clamped, radius?, falloffDistance?, castsShadows?, shadowDarkness?, shadowDiffusion?, position? [x,y,z], poi? [x,y,z]}",
             has_comp,
             new_light
         ),
@@ -710,7 +721,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Light Settings...",
             [],
             None,
-            "{layer?, name?, kind?: Parallel|Spot|Point|Ambient|Environment, color?, intensity?, coneAngle?, coneFeather?, falloff?, radius?, falloffDistance?, castsShadows?, shadowDarkness?, shadowDiffusion?, position?, poi?}",
+            "{layer?, name?, kind?: Parallel|Spot|Point|Ambient|Environment (changing to Environment switches a Classic 3D comp to Advanced 3D), color?, intensity?, coneAngle?, coneFeather?, falloff?, radius?, falloffDistance?, castsShadows?, shadowDarkness?, shadowDiffusion?, position?, poi?}",
             has_comp,
             light_settings
         ),

crates/engine/src/home/demo.rs

@@ -121,7 +121,7 @@ fn lower_third(p: &mut Project) -> Comp {
         [440.0, 914.0],
     );
     anim(&mut title, "transform/opacity", keys(&[(0.4, Value::Scalar(0.0)), (0.9, Value::Scalar(100.0))]));
-    c.layers = vec![title, bar];
+    c.layers = vec![title, bar].into();
     c
 }
 
@@ -270,7 +270,7 @@ fn showcase_3d(p: &mut Project, solids: ItemId) -> Comp {
     );
     anim(&mut caption, "transform/opacity", keys(&[(0.3, Value::Scalar(0.0)), (1.2, Value::Scalar(100.0))]));
 
-    c.layers = vec![caption, cam, key, fill, title, left, right, x1, x2, floor];
+    c.layers = vec![caption, cam, key, fill, title, left, right, x1, x2, floor].into();
     c
 }
 
@@ -463,7 +463,7 @@ pub fn demo_project() -> Project {
     lower.out_point = t(9.5);
 
     // Stack: top first.
-    comp.layers = vec![lower, title, sub, line, burst, rings, null, bg];
+    comp.layers = vec![lower, title, sub, line, burst, rings, null, bg].into();
     for l in &mut comp.layers {
         if l.name == "Controller" {
             l.switches.video = false;

crates/engine/src/menus.rs

@@ -1036,6 +1036,8 @@ Animation
   ---
   Add Keyframe | anim.addKeyframe
   Toggle Hold Keyframe | keys.toggleHold
+  Mute Keyframes | keys.setMuted
+  Unmute Keyframes | keys.setMuted {"muted":false}
   Keyframe Interpolation... | keys.interpolation
   Keyframe Velocity... | keys.velocity
   Keyframe Assistant

crates/engine/src/render_queue.rs

@@ -686,7 +686,7 @@ impl Session {
                         continue;
                     }
                     if let Some(c) = proj.comp_mut(cid) {
-                        for l in c.layers.iter_mut().filter(|l| matches!(l.source, LayerSource::Comp { item } if item == comp)) {
+                        for l in c.layers.iter_mut_where(|l| matches!(l.source, LayerSource::Comp { item } if item == comp)) {
                             l.source = LayerSource::Footage { item: fid };
                         }
                     }

crates/engine/src/scriptui.rs

@@ -402,12 +402,16 @@ pub struct ScriptUi {
     #[serde(skip)]
     pub tasks: Option<ScriptTaskRunner>,
     /// Bumped whenever the project is closed or replaced (New / Open / Close Project): repeating
-    /// tasks of scripts without an open window stop then.
+    /// tasks of scripts without an open window stop then, except those of Startup scripts.
     #[serde(skip)]
     pub project_epoch: u64,
     /// The script contexts of this session with scheduled tasks (kept by the scripting engine).
     #[serde(skip)]
     pub task_hosts: Vec<u32>,
+    /// The script contexts of Startup scripts: their tasks go on when the project is closed or
+    /// replaced, until EffectCraft quits.
+    #[serde(skip)]
+    pub startup_hosts: Vec<u32>,
 }
 
 impl ScriptUi {
@@ -755,6 +759,7 @@ pub(crate) fn mouse(s: &mut Session, p: &Value) -> Result<Value> {
         "screenX": num("screenX", -FAR, FAR, 0.0),
         "screenY": num("screenY", -FAR, FAR, 0.0),
         "button": num("button", 0.0, 2.0, 0.0).round(),
+        "buttons": num("buttons", 0.0, 7.0, 0.0).round(),
         "detail": num("detail", 0.0, 1000.0, clicks).round(),
         "altKey": flag("altKey"),
         "ctrlKey": flag("ctrlKey"),

crates/engine/src/session/render.rs

@@ -96,7 +96,7 @@ impl Session {
             effectcraft_project::ItemKind::Footage(f) if f.has_video => {
                 let f = f.clone();
                 Some(Box::new(move || {
-                    let img = footage.frame(item, &f, Tick(0))?;
+                    let img = effectcraft_render::cineon_frame(footage.frame(item, &f, Tick(0))?, &f);
                     // Point-sample down to at most `max_side` on the long side.
                     let step = (img.width.max(img.height) as f32 / max_side.max(1) as f32).ceil().max(1.0) as u32;
                     let (w, h) = (img.width.div_ceil(step), img.height.div_ceil(step));

crates/engine/src/settings/prefs/choices.rs

@@ -8,6 +8,7 @@ pub const LANGUAGES: &[(&str, &str)] = &[
     ("Deutsch", "de"),
     ("Español", "es"),
     ("Français", "fr"),
+    ("Polski", "pl"),
     ("Português (Brasil)", "pt-br"),
     ("Русский", "ru"),
     ("Українська", "uk"),

crates/engine/src/settings/session_settings.rs

@@ -195,9 +195,19 @@ impl Session {
         self.shortcut_table = std::sync::OnceLock::new();
     }
 
-    /// The active shortcut preset resolved against every bindable command.
+    /// The scripts in the Scripts folder changed: list File ▸ Scripts' entries again in the
+    /// shortcut table.
+    pub fn scripts_changed(&mut self) {
+        self.shortcut_table = std::sync::OnceLock::new();
+    }
+
+    /// The active shortcut preset resolved against every bindable command, File ▸ Scripts'
+    /// entries included.
     pub fn shortcuts(&self) -> &ShortcutTable {
-        self.shortcut_table.get_or_init(|| ShortcutTable::build(&self.keymaps, &self.ui_commands))
+        self.shortcut_table.get_or_init(|| {
+            let scripts: Vec<String> = crate::commands::scripts::scripts(self).into_iter().filter(|e| !e.panel).map(|e| e.name).collect();
+            ShortcutTable::build_with_scripts(&self.keymaps, &self.ui_commands, &scripts)
+        })
     }
 
     /// Remember a project in File ▸ Open Recent and in the crash-recovery sentinel.

crates/engine/src/settings/shortcuts.rs

@@ -1,6 +1,7 @@
 //! Keyboard shortcut presets (Edit ▸ Keyboard Shortcuts).
 //!
-//! Every menu entry, registry command and frontend command is *bindable*: it has a binding key
+//! Every menu entry, registry command and frontend command, and every script File ▸ Scripts
+//! lists, is *bindable*: it has a binding key
 //! (the command id, plus its bound parameters for entries such as `app.settings
 //! {"page":"general"}`), a scope (application-wide or a panel) and default keys. The built-in
 //! preset "EffectCraft Default" is After Effects' default keyboard layout and is read-only; custom
@@ -157,6 +158,27 @@ pub fn bindables(ui: &[UiCommand]) -> Vec<Bindable> {
     out
 }
 
+/// The File ▸ Scripts entries of the scripts `names` (file names, as the menu lists them), with
+/// no default keys. A key is bound to the script's name, so it stays with that script when
+/// scripts are added to or removed from the folder.
+pub fn script_bindables(names: &[String]) -> Vec<Bindable> {
+    names
+        .iter()
+        .map(|n| {
+            let params = json!({"name": n});
+            Bindable {
+                key: binding_key("file.runScript", &params),
+                command: "file.runScript".into(),
+                params,
+                label: n.clone(),
+                path: vec!["File".into(), "Scripts".into()],
+                scope: APP_SCOPE.into(),
+                defaults: vec![],
+            }
+        })
+        .collect()
+}
+
 /// Canonical shortcut text (`cmd+shift+k`, `Shift+Cmd+K`, `⌘⇧K` → `Cmd+Shift+K`); `None` if it
 /// has no key.
 pub fn normalize(s: &str) -> Option<String> {
@@ -436,7 +458,16 @@ pub struct ShortcutTable {
 
 impl ShortcutTable {
     pub fn build(maps: &Keymaps, ui: &[UiCommand]) -> ShortcutTable {
-        let bindables = bindables(ui);
+        Self::build_with_scripts(maps, ui, &[])
+    }
+
+    /// [`ShortcutTable::build`] with the File ▸ Scripts entries of the scripts `scripts`, listed
+    /// after the other File ▸ Scripts entries.
+    pub fn build_with_scripts(maps: &Keymaps, ui: &[UiCommand], scripts: &[String]) -> ShortcutTable {
+        let mut bindables = bindables(ui);
+        let at = bindables.iter().rposition(|b| b.path.starts_with(&["File".to_string(), "Scripts".to_string()])).map_or(bindables.len(), |i| i + 1);
+        let new: Vec<Bindable> = script_bindables(scripts).into_iter().filter(|s| !bindables.iter().any(|b| b.key == s.key)).collect();
+        bindables.splice(at..at, new);
         let keys = bindables.iter().map(|b| (b.key.clone(), maps.keys_of(b))).collect();
         ShortcutTable { bindables, keys }
     }

crates/engine/src/system/perf.rs

@@ -180,7 +180,7 @@ pub fn large_project(spec: &LargeSpec) -> Project {
             *n += 1;
             layers.push(l);
         }
-        comp.layers = layers;
+        comp.layers = layers.into();
     };
     let others = spec.comps.saturating_sub(1);
     let depth = spec.nest_depth.min(others);
@@ -215,7 +215,7 @@ pub fn large_project(spec: &LargeSpec) -> Project {
         n += 1;
         layers.push(l);
     }
-    main.layers = layers;
+    main.layers = layers.into();
     p.add_item("Main", crate::color::Label::None, None, ItemKind::Comp(Arc::new(main)));
     // `Main` must be the first comp `replace_project` opens: give it the smallest id.
     let main_id = p.items.values().find(|i| i.name == "Main").map(|i| i.id).expect("main");

crates/engine/src/tests.rs

@@ -41,6 +41,7 @@ pub(crate) mod roto;
 mod sequence;
 mod session;
 mod settings;
+mod shared_layers;
 mod shortcut_cmds;
 pub(crate) mod stubs;
 mod styles;

crates/engine/src/tests/effects.rs

@@ -550,7 +550,7 @@ fn opening_an_old_project_upgrades_effect_instances() {
             effectcraft_project::ItemKind::Comp(c) => c,
             _ => panic!("not a composition"),
         });
-        let l = comp.layers.iter_mut().find(|l| l.id == LayerId(a)).unwrap();
+        let l = comp.layers.find_mut(|l| l.id == LayerId(a)).unwrap();
         for n in &mut l.props.sub_mut("effects").unwrap().children {
             let Node::Group(g) = n else { continue };
             if g.match_id == "ec.blur.gaussian" {

crates/engine/src/tests/menu_cmds.rs

@@ -1483,6 +1483,68 @@ fn key_selection_toggles_and_skips_locked_layers_and_hold_restores_bezier() {
     assert!(s.state.selected_keys.is_empty());
 }
 
+#[test]
+fn muting_keys_skips_them_in_the_timeline_value_and_undoes() {
+    let mut s = comp();
+    let a = solid(&mut s, "#ff0000");
+    for (t, v) in [(0.0, 0.0), (1.0, 100.0), (2.0, 300.0)] {
+        s.execute("prop.addKey", json!({"layer": a, "path": "transform/opacity", "time": t, "value": v})).unwrap();
+    }
+    let value_at = |s: &Session, t: f64| layer(s, a).props.prop("transform/opacity").unwrap().value_at(Tick::from_seconds_f64(t)).as_f64();
+    let select = |s: &mut Session| s.execute("keys.select", json!({"keys": [{"layer": a, "path": "transform/opacity", "time": 1.0}]})).unwrap();
+    select(&mut s);
+    let before = value_at(&s, 0.5);
+    s.execute("keys.setMuted", json!({"muted": true})).unwrap();
+    assert!(layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+    // The muted key no longer bends the 0 → 300 segment.
+    assert!((value_at(&s, 0.5) - 75.0).abs() < 1e-6);
+    assert!((value_at(&s, 1.5) - 225.0).abs() < 1e-6);
+    s.undo();
+    assert!(!layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+    assert!((value_at(&s, 0.5) - before).abs() < 1e-6);
+    // The same command unmutes.
+    select(&mut s);
+    s.execute("keys.setMuted", json!({"muted": true})).unwrap();
+    s.execute("keys.setMuted", json!({"muted": false})).unwrap();
+    assert!(!layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+}
+
+/// Both Animation-menu rows mute and unmute through `Session::execute`, and undo/redo work.
+#[test]
+fn mute_and_unmute_keyframes_menu_rows_work_and_undo() {
+    fn rows(nodes: &[crate::menus::MenuNode], out: &mut Vec<(String, Value)>) {
+        for n in nodes {
+            match n {
+                crate::menus::MenuNode::Item(e) if e.command == "keys.setMuted" => out.push((e.label.clone(), e.params.clone())),
+                crate::menus::MenuNode::Submenu { children, .. } => rows(children, out),
+                _ => {}
+            }
+        }
+    }
+    let mut menu = vec![];
+    rows(&crate::menus::parse(crate::menus::TREE, false).unwrap(), &mut menu);
+    assert_eq!(menu.iter().map(|(l, _)| l.as_str()).collect::<Vec<_>>(), ["Mute Keyframes", "Unmute Keyframes"], "{menu:?}");
+
+    let mut s = comp();
+    let a = solid(&mut s, "#ff0000");
+    for (t, v) in [(0.0, 0.0), (1.0, 100.0)] {
+        s.execute("prop.addKey", json!({"layer": a, "path": "transform/opacity", "time": t, "value": v})).unwrap();
+    }
+    let muted = |s: &Session| layer(s, a).props.prop("transform/opacity").unwrap().keys[1].muted;
+    s.execute("keys.select", json!({"keys": [{"layer": a, "path": "transform/opacity", "time": 1.0}]})).unwrap();
+    let run = |s: &mut Session, params: &Value| {
+        s.execute("keys.setMuted", if params.is_null() { json!({}) } else { params.clone() }).unwrap();
+    };
+    run(&mut s, &menu[0].1);
+    assert!(muted(&s));
+    s.undo();
+    assert!(!muted(&s));
+    s.redo();
+    assert!(muted(&s));
+    run(&mut s, &menu[1].1);
+    assert!(!muted(&s));
+}
+
 #[test]
 fn transform_drags_apply_their_whole_offset_to_the_keys_they_started_with() {
     let mut s = comp();

crates/engine/src/tests/proxy.rs

@@ -1,6 +1,6 @@
 //! Proxies (Set Proxy, Use Proxy, Proxy Use render settings, comp proxies, Create Proxy) and
-//! Interpret Footage (fields, pixel aspect, alpha guess / invert, linear light), rendered through
-//! a synthetic footage source.
+//! Interpret Footage (fields, pixel aspect, alpha guess / invert, linear light, Cineon Settings),
+//! rendered through a synthetic footage source.
 
 use std::sync::Arc;
 
@@ -36,6 +36,12 @@ fn file_px(path: &str, x: u32, y: u32) -> [f32; 4] {
         "matte_black.png" => [0.0, 0.5, 0.0, 0.5],
         "matte_white.png" => [0.5, 1.0, 0.5, 0.5],
         "half.png" => [1.0, 1.0, 1.0, 0.25],
+        // A log film scan: code values 95, 685, 400 and 1023 across, as the DPX reader hands
+        // them out (code / 1023).
+        "scan.dpx" | "plate.dpx" => {
+            let v = [95.0, 685.0, 400.0, 1023.0][x.min(3) as usize] / 1023.0;
+            [v, v, v, 1.0]
+        }
         _ => {
             let _ = x;
             [1.0, 1.0, 1.0, 1.0]
@@ -47,7 +53,7 @@ fn size_of(path: &str) -> (u32, u32) {
     match std::path::Path::new(path).file_name().and_then(std::ffi::OsStr::to_str).unwrap_or("") {
         "red16.png" => (16, 16),
         "blue8.png" => (8, 8),
-        "lines.mov" | "matte_black.png" | "matte_white.png" | "half.png" => (4, 4),
+        "lines.mov" | "matte_black.png" | "matte_white.png" | "half.png" | "scan.dpx" | "plate.dpx" => (4, 4),
         _ => (10, 10),
     }
 }
@@ -64,7 +70,12 @@ impl FootageSource for Synthetic {
         for y in 0..h {
             for x in 0..w {
                 // Decoders hand out premultiplied pixels (straight file colour × alpha).
-                let p = file_px(&f.path, x, y);
+                let mut p = file_px(&f.path, x, y);
+                // A log scan sequence: code 95 on even frames, 685 on odd ones.
+                if f.path.ends_with("frames.dpx") {
+                    let v = if f.frame_rate.frame_at(t) % 2 == 0 { 95.0 } else { 685.0 } / 1023.0;
+                    p = [v, v, v, 1.0];
+                }
                 img.set(x, y, [p[0] * p[3], p[1] * p[3], p[2] * p[3], p[3]]);
             }
         }
@@ -76,7 +87,7 @@ struct Probe;
 impl crate::Importer for Probe {
     fn probe(&self, path: &str) -> Result<Footage, String> {
         let (w, h) = size_of(path);
-        let video = path.ends_with(".mov");
+        let video = path.ends_with(".mov") || path.ends_with("frames.dpx");
         Ok(Footage {
             path: path.into(),
             kind: if video { FootageKind::Video } else { FootageKind::Still },
@@ -431,3 +442,125 @@ fn guess_alpha_invert_and_linear_light() {
     s.execute("file.applyInterpretation", json!({"items": [w.0]})).unwrap();
     assert!(foot(&s, w).preserve_rgb);
 }
+
+/// Color ▸ Cineon Settings: Logarithmic Conversion turns a DPX file's log code values into the
+/// Current Gamma between the converted points (off, they show as stored); the converted points
+/// are read and reported in the chosen Units; out-of-range values and footage that is not DPX
+/// or Cineon are refused; Remember / Apply Interpretation and undo carry the settings.
+#[test]
+fn cineon_settings_convert_dpx_code_values() {
+    let mut s = session();
+    let d = import(&mut s, "/m/scan.dpx");
+    let other = import(&mut s, "/m/plate.dpx");
+    let png = import(&mut s, "/m/red16.png");
+    let foot = |s: &Session, i: ItemId| match &s.project.item(i).unwrap().kind {
+        ItemKind::Footage(f) => f.clone(),
+        _ => panic!("not footage"),
+    };
+    s.execute("comp.new", json!({"name": "C", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+    let c = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": d.0})).unwrap();
+    let at = |s: &Session, x: i64| px(s, c, 0.0, RenderOpts::default(), x, 0)[0];
+    let near = |a: f32, b: f32| (a - b).abs() < 1.5 / 255.0;
+    // Off: the code values as stored.
+    assert!(near(at(&s, 2), 400.0 / 1023.0), "{}", at(&s, 2));
+    // The checked path (control channel, MCP) accepts every Cineon parameter the doc lists.
+    let out = s.execute_checked("file.interpretFootage", json!({"items": [d.0], "logConversion": true, "highlightRolloff": 0})).unwrap();
+    assert_eq!(out["items"][0]["cineon"]["logConversion"], true, "{out}");
+    assert!(near(at(&s, 0), 0.0) && near(at(&s, 1), 1.0), "{} {}", at(&s, 0), at(&s, 1));
+    assert!(near(at(&s, 2), 0.26190), "code 400 at gamma 1.7: {}", at(&s, 2));
+    s.execute("file.interpretFootage", json!({"item": d.0, "currentGamma": 1})).unwrap();
+    assert!(near(at(&s, 2), 0.10251), "code 400 in linear light: {}", at(&s, 2));
+    // Converted points, in 8-bit units.
+    let out = s
+        .execute_checked("file.interpretFootage", json!({"items": [d.0], "cineonUnits": "8bit", "convertedBlack": 16, "convertedWhite": 235, "currentGamma": 1, "tenBitBlack": 95, "tenBitWhite": 685}))
+        .unwrap();
+    assert_eq!(out["items"][0]["cineon"]["units"], "8bit");
+    assert!((out["items"][0]["cineon"]["convertedWhite"].as_f64().unwrap() - 235.0).abs() < 1e-3, "{out}");
+    assert!(near(at(&s, 0), 16.0 / 255.0) && near(at(&s, 1), 235.0 / 255.0), "{} {}", at(&s, 0), at(&s, 1));
+    // The form sends the points in the units it showed them in (`pointUnits`) with a new Units.
+    s.execute_checked("file.interpretFootage", json!({"items": [d.0], "pointUnits": "8bit", "cineonUnits": "float", "convertedWhite": 255})).unwrap();
+    let f = foot(&s, d);
+    assert_eq!(f.cineon.units, effectcraft_project::CineonUnits::Float);
+    assert!((f.cineon.converted_white - 1023.0).abs() < 1e-3, "{:?}", f.cineon);
+    // Refused: a black point at or above the white point, values out of range, and footage
+    // that is not DPX or Cineon. Nothing changes.
+    let before = foot(&s, d).cineon;
+    for bad in [
+        json!({"item": d.0, "tenBitBlack": 700}),
+        json!({"item": d.0, "tenBitWhite": 2000}),
+        json!({"item": d.0, "currentGamma": 0}),
+        json!({"item": d.0, "highlightRolloff": -1}),
+        json!({"item": d.0, "convertedWhite": 1.5}),
+        json!({"item": d.0, "cineonUnits": "12bit"}),
+        json!({"item": png.0, "logConversion": true}),
+    ] {
+        assert!(s.execute("file.interpretFootage", bad.clone()).is_err(), "{bad}");
+    }
+    assert_eq!(foot(&s, d).cineon, before);
+    assert!(foot(&s, png).cineon == effectcraft_project::CineonSettings::default());
+    // With DPX and other footage selected, only the DPX file takes the settings.
+    s.execute("file.interpretFootage", json!({"items": [png.0, other.0], "logConversion": true})).unwrap();
+    assert!(foot(&s, other).cineon.log_conversion && !foot(&s, png).cineon.log_conversion);
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(!foot(&s, other).cineon.log_conversion);
+    // Remember / Apply Interpretation.
+    s.state.project_selection = vec![d];
+    s.execute("file.rememberInterpretation", json!({"item": d.0})).unwrap();
+    s.execute("file.applyInterpretation", json!({"items": [other.0, png.0]})).unwrap();
+    assert_eq!(foot(&s, other).cineon, before);
+    assert_eq!(foot(&s, png).cineon, effectcraft_project::CineonSettings::default());
+    // Off again: as stored.
+    s.execute("file.interpretFootage", json!({"item": d.0, "logConversion": false})).unwrap();
+    assert!(near(at(&s, 2), 400.0 / 1023.0), "{}", at(&s, 2));
+    // Frame Mix blends converted frames: halfway between code 95 (black) and 685 (white) at
+    // Current Gamma 1 is 0.5, not the conversion of the blended code values.
+    let seq = import(&mut s, "/m/frames.dpx");
+    s.execute("file.interpretFootage", json!({"item": seq.0, "logConversion": true, "currentGamma": 1, "highlightRolloff": 0})).unwrap();
+    s.execute("comp.new", json!({"name": "Blend", "width": 10, "height": 10, "frameRate": 20, "duration": 1})).unwrap();
+    let bc = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": seq.0})).unwrap();
+    s.execute("layer.frameBlending", json!({"mode": "frameMix"})).unwrap();
+    let mid = px(&s, bc, 0.05, RenderOpts::default(), 5, 5)[0];
+    assert!(near(mid, 0.5), "frame-mixed log frames: {mid}");
+    // A DPX proxy of a composition: Interpret Proxy's settings convert it where it stands in.
+    s.execute("comp.new", json!({"name": "Inner", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+    let inner = s.active_comp_id().unwrap();
+    s.execute("comp.new", json!({"name": "Outer", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+    let outer = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": inner.0})).unwrap();
+    s.execute("file.setProxy", json!({"item": inner.0, "path": "/m/scan.dpx"})).unwrap();
+    let proxied = |s: &Session, x: i64| px(s, outer, 0.0, RenderOpts::default(), x, 0)[0];
+    assert!(near(proxied(&s, 1), 685.0 / 1023.0), "{}", proxied(&s, 1));
+    s.execute_checked("file.interpretProxy", json!({"items": [inner.0], "logConversion": true, "highlightRolloff": 0})).unwrap();
+    assert!(near(proxied(&s, 0), 0.0) && near(proxied(&s, 1), 1.0), "{} {}", proxied(&s, 0), proxied(&s, 1));
+}
+
+/// The Footage panel, the Project panel thumbnail and the tracker's source frames show DPX
+/// footage with its Cineon Settings, as a composition renders it.
+#[test]
+fn cineon_settings_apply_to_footage_panel_thumbnail_and_tracking() {
+    let mut s = session();
+    let d = import(&mut s, "/m/scan.dpx");
+    s.execute("comp.new", json!({"name": "C", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+    let c = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": d.0})).unwrap();
+    s.execute("file.interpretFootage", json!({"item": d.0, "logConversion": true, "highlightRolloff": 0})).unwrap();
+    let near = |a: f32, b: f32| (a - b).abs() < 1.5 / 255.0;
+    let rendered = px(&s, c, 0.0, RenderOpts::default(), 2, 0)[0];
+    assert!(near(rendered, 0.26190), "code 400 at gamma 1.7: {rendered}");
+    let f = match &s.project.item(d).unwrap().kind {
+        ItemKind::Footage(f) => f.clone(),
+        _ => panic!("not footage"),
+    };
+    let panel = crate::commands::footage_panel::frame(&s, d, &f, Tick::ZERO).unwrap().get(2, 0)[0];
+    assert!(near(panel, rendered), "Footage panel: {panel}");
+    let (w, _, rgba) = (s.thumbnail_job(d, Tick::ZERO, 64).unwrap())().unwrap();
+    assert_eq!(w, 4);
+    let thumb = rgba[8] as f32 / 255.0;
+    assert!(near(thumb, rendered), "Project panel thumbnail: {thumb}");
+    let comp = s.project.comp(c).unwrap();
+    let r = crate::render::Renderer::new(&s.project, s.footage.as_ref(), RenderOpts::default());
+    let (img, _) = crate::tracking::source_frame(&r, &s.project, c, comp, &comp.layers[0], Tick::ZERO, None).unwrap();
+    assert!(near(img.get(2, 0)[0], rendered), "tracker source frame: {}", img.get(2, 0)[0]);
+}

crates/engine/src/tests/session.rs

@@ -86,7 +86,7 @@ fn imported_files_go_into_the_comp_where_they_were_dropped() {
     s.execute("file.import", params).unwrap();
     let comp = s.active_comp().unwrap();
     assert_eq!(comp.layers.iter().map(|l| l.name.as_str()).collect::<Vec<_>>(), ["a.png", "b.png", "Bg"]);
-    for l in &comp.layers[..2] {
+    for l in comp.layers.iter().take(2) {
         assert_eq!(l.props.prop("transform/position").map(|p| p.value.clone()), Some(effectcraft_keyframe::Value::Vec3([40.0, 50.0, 0.0])));
         assert_eq!(l.in_point, effectcraft_time::Tick::from_seconds_f64(1.0));
     }
@@ -159,6 +159,46 @@ fn background_imports_report_progress_and_select_what_arrived() {
     assert_eq!(r["items"].as_array().map(Vec::len), Some(1));
 }
 
+/// #2573: New Composition From Footage (`file.import {newComp}`) makes one composition of what
+/// the import made, first file on top, at once or when the background job lands; an import that
+/// made nothing makes no comp.
+#[test]
+fn new_comp_from_footage_makes_a_comp_of_what_was_imported() {
+    use effectcraft_project::{Footage, FootageKind, ItemKind};
+    struct Probe;
+    impl crate::Importer for Probe {
+        fn probe(&self, path: &str) -> Result<Footage, String> {
+            if path.ends_with(".xyz") {
+                return Err("unsupported file".into());
+            }
+            Ok(Footage { path: path.into(), kind: FootageKind::Still, width: 64, height: 32, has_video: true, ..Default::default() })
+        }
+    }
+    let mut s = Session { importer: Some(std::sync::Arc::new(Probe)), ..Default::default() };
+    let comps = |s: &Session| s.project.items.values().filter(|i| matches!(i.kind, ItemKind::Comp(_))).count();
+    let layers = |s: &Session| s.active_comp().unwrap().layers.iter().map(|l| l.name.clone()).collect::<Vec<_>>();
+    // At once.
+    s.execute("file.import", json!({"paths": ["/drop/a.png", "/drop/b.xyz"], "newComp": true})).unwrap();
+    assert_eq!(comps(&s), 1);
+    assert_eq!(layers(&s), ["a.png"]);
+    assert_eq!((s.active_comp().unwrap().width, s.active_comp().unwrap().height), (64, 32));
+    // In the background: the job's own items, whatever is selected or active meanwhile; it takes
+    // precedence over `addToComp`.
+    s.execute("file.import", json!({"paths": ["/drop/c.png", "/drop/d.png"], "background": true, "newComp": true, "addToComp": true})).unwrap();
+    s.state.project_selection.clear();
+    s.execute("jobs.wait", json!({})).unwrap();
+    assert_eq!(comps(&s), 2);
+    assert_eq!(layers(&s), ["c.png", "d.png"]);
+    // Nothing imported: no comp, and the failure is reported.
+    s.execute("file.import", json!({"paths": ["/drop/e.xyz"], "background": true, "newComp": true})).unwrap();
+    s.execute("jobs.wait", json!({})).unwrap();
+    assert_eq!(comps(&s), 2);
+    assert!(s.job_log.last().unwrap().message.contains("unsupported file"));
+    let r = s.execute("file.import", json!({"paths": ["/drop/f.xyz"], "newComp": true})).unwrap();
+    assert_eq!(comps(&s), 2);
+    assert_eq!(r["errors"].as_array().map(Vec::len), Some(1));
+}
+
 /// Audio, Lock and Shy don't change pixels: toggling them keeps the cached layers (#103).
 #[test]
 fn audio_lock_and_shy_keep_cached_layers() {

crates/engine/src/tests/settings.rs

@@ -1089,6 +1089,14 @@ fn interface_language_is_validated_persisted_and_backward_compatible() {
     cs.load_settings();
     assert_eq!(cs.prefs.general.language, "cs");
     assert_eq!(Prefs::from_json(r#"{"general":{"language":"cs"}}"#).general.language, "cs");
+    // Polish, likewise.
+    assert!(crate::prefs::LANGUAGES.contains(&("Polski", "pl")));
+    s.execute("prefs.set", json!({"key": "general.language", "value": "pl"})).unwrap();
+    assert_eq!(s.execute("prefs.get", json!({"key": "general.language"})).unwrap(), json!("pl"));
+    let mut pl = Session { config: Some(store.clone()), ..Default::default() };
+    pl.load_settings();
+    assert_eq!(pl.prefs.general.language, "pl");
+    assert_eq!(Prefs::from_json(r#"{"general":{"language":"pl"}}"#).general.language, "pl");
     // Georgian too.
     assert!(crate::prefs::LANGUAGES.contains(&("ქართული", "ka")));
     s.execute("prefs.set", json!({"key": "general.language", "value": "ka"})).unwrap();

crates/engine/src/tests/shared_layers.rs

@@ -0,0 +1,42 @@
+//! An edit copies only the layer it changes: the others stay shared with the undo state, so an
+//! edit's cost doesn't grow with the size of the comp (scripts setting many keys went quadratic).
+
+use std::sync::Arc;
+
+use serde_json::json;
+
+use crate::Session;
+
+#[test]
+fn a_key_on_one_layer_leaves_the_other_layers_shared_with_undo() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Big", "duration": 10, "frameRate": 30})).unwrap();
+    let ids: Vec<u64> = (0..20).map(|i| s.execute("layer.newNull", json!({"name": format!("N{i}")})).unwrap()["layer"].as_u64().unwrap()).collect();
+    let cid = s.active_comp_id().unwrap();
+    let before = s.project.clone();
+    s.execute("prop.addKey", json!({"layer": ids[7], "path": "transform/position", "time": 1.0, "value": [5, 5]})).unwrap();
+    let (old, new) = (before.comp(cid).unwrap(), s.project.comp(cid).unwrap());
+    assert_eq!(old.layers.len(), new.layers.len());
+    let edited = new.layers.iter().position(|l| l.id.0 == ids[7]).unwrap();
+    for i in 0..new.layers.len() {
+        assert_eq!(new.layers.same_at(&old.layers, i), i != edited, "layer {i} shared: {}", new.layers.same_at(&old.layers, i));
+    }
+    // Undo brings back the very same state, and the edited layer is the only one that differed.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(Arc::ptr_eq(&s.project, &before));
+}
+
+#[test]
+fn layers_save_and_load_as_a_plain_list() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Round trip", "duration": 5, "frameRate": 25})).unwrap();
+    for i in 0..3 {
+        s.execute("layer.newNull", json!({"name": format!("N{i}")})).unwrap();
+    }
+    let cid = s.active_comp_id().unwrap();
+    let comp = s.project.comp(cid).unwrap();
+    let text = serde_json::to_value(&comp.layers).unwrap();
+    assert_eq!(text.as_array().map(Vec::len), Some(3), "a JSON array of layers, as before");
+    let back: effectcraft_project::Layers = serde_json::from_value(text).unwrap();
+    assert_eq!(&back, &comp.layers);
+}

crates/engine/src/tests/three_d.rs

@@ -1,6 +1,6 @@
 //! 3D commands: cameras, lights, views, camera tools (with undo/redo), and the 3D demo comp.
 
-use effectcraft_project::{AutoOrient, LayerSource, LightKind};
+use effectcraft_project::{AutoOrient, LayerSource, LightKind, Renderer};
 use effectcraft_render::three_d::View3D;
 use serde_json::json;
 
@@ -148,6 +148,85 @@ fn deleting_a_source_layer_clears_the_reference() {
     assert!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(sky)).is_some());
 }
 
+/// #2436: only the Advanced 3D renderer lights with Environment lights, and new comps are
+/// Classic 3D, so one had no visible effect. Adding one (or changing a light into one) switches
+/// the comp to Advanced 3D (in the same undo step, with a toast), as After Effects does.
+#[test]
+fn environment_lights_switch_classic_comps_to_advanced_3d() {
+    let toasts = |s: &mut Session| -> Vec<String> {
+        s.drain_events().into_iter().filter_map(|e| if let crate::Event::Toast { message, .. } = e { Some(message) } else { None }).collect()
+    };
+    let mut s = session();
+    let text = s.execute("layer.newText", json!({"text": "Hi"})).unwrap()["layer"].as_u64().unwrap();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D);
+    toasts(&mut s);
+    let r = s.execute("layer.newLight", json!({"kind": "Environment"})).unwrap();
+    assert_eq!(r["advanced3d"], true);
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Advanced3D);
+    // As with Composition Settings: the text layer gets Geometry Options.
+    assert!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(text)).unwrap().props.sub("geometryOptions").is_some());
+    assert!(toasts(&mut s).iter().any(|m| m.contains("Advanced 3D")));
+    // A second Environment light leaves the comp (and the user) alone.
+    s.execute("layer.newLight", json!({"kind": "Environment"})).unwrap();
+    assert!(toasts(&mut s).is_empty());
+    // Undoing the creations takes the lights and the switch back together.
+    s.undo();
+    s.undo();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D);
+    assert_eq!(layer_count(&s), 1);
+    // Changing a light to Environment switches too, and undoes with the type.
+    let spot = s.execute("layer.newLight", json!({"kind": "Spot"})).unwrap()["layer"].as_u64().unwrap();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D);
+    s.execute("layer.lightSettings", json!({"layer": spot, "kind": "Environment"})).unwrap();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Advanced3D);
+    s.undo();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D);
+    assert_eq!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(spot)).unwrap().source, LayerSource::Light { kind: LightKind::Spot });
+    // Other light types never switch it.
+    s.execute("layer.newLight", json!({"kind": "Point"})).unwrap();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D);
+    // Switching back to Classic 3D with an Environment light in the comp explains itself.
+    let env = s.execute("layer.newLight", json!({"kind": "Environment"})).unwrap()["layer"].as_u64().unwrap();
+    toasts(&mut s);
+    s.execute("comp.renderer", json!({"renderer": "classic3d"})).unwrap();
+    assert!(toasts(&mut s).iter().any(|m| m.contains("Environment light")), "the Classic 3D limit is explained");
+    // Editing that Environment light (no type change) leaves the renderer the user chose.
+    s.execute("layer.lightSettings", json!({"layer": env, "intensity": 80})).unwrap();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D, "an ordinary edit doesn't re-switch");
+    assert!(toasts(&mut s).is_empty(), "and doesn't toast either");
+}
+
+/// An Environment light takes Casts Shadows (with Shadow Darkness and Diffusion) like every
+/// other light — the Light Settings dialog offers them for all types but Ambient — and keeps no
+/// Falloff, which an environment light shining from every direction has no use for (#2436).
+#[test]
+fn environment_light_takes_shadow_options_but_no_falloff() {
+    let mut s = session();
+    let env = s.execute("layer.newLight", json!({"kind": "Environment", "castsShadows": true, "shadowDarkness": 60, "shadowDiffusion": 12})).unwrap()["layer"]
+        .as_u64()
+        .unwrap();
+    assert!(prop(&s, env, "lightOptions/castsShadows").as_bool());
+    assert_eq!(prop(&s, env, "lightOptions/shadowDarkness").as_f64(), 60.0);
+    assert_eq!(prop(&s, env, "lightOptions/shadowDiffusion").as_f64(), 12.0);
+    assert!(
+        s.active_comp().unwrap().layer(effectcraft_project::LayerId(env)).unwrap().props.prop("lightOptions/falloff").is_none(),
+        "an environment light has no Falloff"
+    );
+    // The shadow values carry over when the type changes, both ways.
+    s.execute("layer.lightSettings", json!({"layer": env, "kind": "Spot", "coneAngle": 70})).unwrap();
+    assert!(prop(&s, env, "lightOptions/castsShadows").as_bool());
+    assert_eq!(prop(&s, env, "lightOptions/shadowDarkness").as_f64(), 60.0);
+    assert_eq!(prop(&s, env, "lightOptions/coneAngle").as_f64(), 70.0);
+    s.execute("layer.lightSettings", json!({"layer": env, "kind": "Environment"})).unwrap();
+    assert!(prop(&s, env, "lightOptions/castsShadows").as_bool());
+    assert_eq!(prop(&s, env, "lightOptions/source").as_layer(), None, "back to Environment: it has a Source again");
+    s.undo();
+    assert!(
+        s.active_comp().unwrap().layer(effectcraft_project::LayerId(env)).unwrap().props.prop("lightOptions/coneAngle").is_some(),
+        "back to Spot: it has a Cone Angle again"
+    );
+}
+
 #[test]
 fn three_d_switch_undo_redo() {
     let mut s = session();

crates/engine/src/tests/vector_import.rs

@@ -160,6 +160,37 @@ fn psd_imports_as_composition() {
     assert!(s.project.comp(cid).is_none());
 }
 
+/// #2573: New Composition From Footage on a Photoshop file imported as a composition opens that
+/// composition; it isn't wrapped in another.
+#[test]
+fn psd_imported_as_composition_with_new_comp_is_the_new_comp() {
+    let path = tmp("newcomp.psd");
+    std::fs::write(&path, sample_psd()).unwrap();
+    let mut s = Session::default();
+    let r = s.execute_checked("file.import", json!({"paths": [path], "importAs": "composition", "newComp": true})).unwrap();
+    assert_eq!(r["errors"], json!([]), "{r}");
+    let cid = effectcraft_project::ItemId(r["comps"][0].as_u64().unwrap());
+    assert_eq!(s.state.active_comp, Some(cid));
+    let roots = s.project.items.values().filter(|i| matches!(i.kind, ItemKind::Comp(_)) && i.name.starts_with("newcomp")).count();
+    assert_eq!(roots, 1, "no wrapper comp");
+}
+
+/// A Photoshop file imported as a composition and dropped on the Timeline (`addToComp`) adds
+/// its composition once, not its folder too.
+#[test]
+fn psd_imported_as_composition_into_a_comp_adds_one_layer() {
+    let path = tmp("dropped.psd");
+    std::fs::write(&path, sample_psd()).unwrap();
+    let mut s = Session::default();
+    let main = s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "frameRate": 30, "duration": 4})).unwrap()["comp"].as_u64().unwrap();
+    let r = s.execute_checked("file.import", json!({"paths": [path], "importAs": "composition", "addToComp": true})).unwrap();
+    assert_eq!(r["errors"], json!([]), "{r}");
+    let psd = r["comps"][0].as_u64().unwrap();
+    let layers = &s.project.comp(effectcraft_project::ItemId(main)).unwrap().layers;
+    assert_eq!(layers.len(), 1, "{layers:?}");
+    assert!(matches!(layers[0].source, LayerSource::Comp { item } if item.0 == psd));
+}
+
 #[test]
 fn psd_retain_layer_sizes() {
     let path = tmp("retain.psd");

crates/export/tests/it/movie_bytes.rs

@@ -61,7 +61,7 @@ fn project() -> (Project, ItemId) {
     }
     box_.blend_mode = BlendMode::Screen;
 
-    comp.layers = vec![box_, ring, solid];
+    comp.layers = vec![box_, ring, solid].into();
     let cid = p.add_item("Comp 1", Label::Sandstone, None, ItemKind::Comp(comp.into()));
     (p, cid)
 }

crates/expr/src/prelude.js

@@ -31,6 +31,7 @@ function __begin(t, v, c, l, path, uid, idx, fd, ti, tt, sv) {
   __seed = 0;
   __timeless = false;
   __projectInfo = null;
+  __layersTrim();
 }
 
 function __finish(r) {
@@ -44,7 +45,7 @@ function __finish(r) {
 
 function __result(r) {
   r = __v(r);
-  if (r !== null && typeof r === 'object' && r.__isLayer) return r.index;
+  if (typeof r === 'function' && r.__isLayer) return r.index;
   if (r !== null && typeof r === 'object' && r.__isTextStyle) return r.__out();
   // `[temp, temp]` where temp is a property (pick-whip 1D → 2D): read the values here, while
   // host requests can still be answered and the script re-run.
@@ -488,7 +489,7 @@ function __ancestor(c, l, path, countUp) {
   if (typeof n !== 'number' || !(n >= 1) || !isFinite(n)) __err('propertyGroup(' + countUp + '): the count must be a number of 1 or more');
   n = Math.floor(n);
   var info = __h(__ANCESTOR, c, l, path, n);
-  if (info === 'layer') return new Layer(c, l);
+  if (info === 'layer') return __layer(c, l);
   if (info === null) __err('propertyGroup(' + n + ') goes above the layer');
   return __mkGroup(c, l, info);
 }
@@ -518,10 +519,10 @@ Comp.prototype = {
     return __err('Composition "' + this.name + '" has no active camera');
   },
   layer: function (a, rel) {
-    if (a !== null && typeof a === 'object' && a.__isLayer) return this.layer(a.index + (rel || 0));
+    if (typeof a === 'function' && a.__isLayer) return this.layer(a.index + (rel || 0));
     var id = __h(__LAYER, this.__c, a);
     if (id === null) __err(typeof a === 'string' ? 'Layer named "' + a + '" does not exist' : 'Layer index ' + a + ' out of range');
-    return new Layer(this.__c, id);
+    return __layer(this.__c, id);
   },
   toString: function () { return '[object Comp]'; },
 };
@@ -596,7 +597,55 @@ var thisProject = {
 
 // Layer -----------------------------------------------------------------------------------------
 
-function Layer(c, l) { this.__c = c; this.__l = l; this.__i = null; }
+// A layer is a property group too, as in After Effects: `thisLayer("transform")`, another layer's
+// `("effects")("Slider Control")`, `thisLayer(1)` (what the pick whip writes with Compact English
+// off). Callable like a group (`__mkGroup`), with the Layer methods.
+function Layer(c, l) {
+  var f = function (k) { return f.__group(k); };
+  delete f.name;
+  delete f.length;
+  Object.setPrototypeOf(f, Layer.prototype);
+  // Kept across evaluations (`__layer`), so an expression can't change which layer it is, delete
+  // a field or leave its own on it. Its info is private to `__info`, which reads it again in an
+  // evaluation whose `__S` isn't the one it was read in (every evaluation has a new `__S`), so
+  // freezing the layer can't keep its info either.
+  var info = null, read = null;
+  Object.defineProperty(f, '__c', { value: c });
+  Object.defineProperty(f, '__l', { value: l });
+  Object.defineProperty(f, '__info', {
+    get: function () {
+      if (read !== __S) { info = __h(__LINFO, c, l); read = __S; }
+      return info;
+    },
+  });
+  Object.preventExtensions(f);
+  return f;
+}
+
+// Layer `l` of comp `c`, made once per runtime: a callable Layer is dearer to make than a plain
+// object, so it is kept, and its info (`__info`) is read again in each evaluation.
+// The kept layers are out of an expression's reach (their maps have no prototype, so a change to
+// `Object.prototype` doesn't reach them either), and bounded like the runtime's scripts: once
+// `max` are kept, the layers after them aren't, and the next evaluation starts over
+// (`__layersTrim`, so a layer stays the same object for a whole evaluation).
+var __layer, __layersTrim;
+(function () {
+  var layers = Object.create(null), kept = 0, max = 4096;
+  __layer = function (c, l) {
+    // By comp, then layer: a `c + ':' + l` key costs more to build than the lookup saves.
+    var m = layers[c], f = m && m[l];
+    if (f) return f;
+    f = new Layer(c, l);
+    if (kept < max) {
+      (m || (layers[c] = Object.create(null)))[l] = f;
+      kept++;
+    }
+    return f;
+  };
+  __layersTrim = function () {
+    if (kept >= max) { layers = Object.create(null); kept = 0; }
+  };
+})();
 
 function __m3(m, p) {
   var x = p[0] || 0, y = p[1] || 0;
@@ -620,7 +669,6 @@ function __m4(m, p, vec) {
 
 Layer.prototype = {
   __isLayer: true,
-  get __info() { return this.__i || (this.__i = __h(__LINFO, this.__c, this.__l)); },
   get name() { return this.__info[0]; },
   get index() { return this.__info[1]; },
   get inPoint() { return this.__info[2]; },
@@ -632,7 +680,7 @@ Layer.prototype = {
   get parent() {
     var p = this.__info[7];
     if (p === null) __err('Layer "' + this.name + '" has no parent');
-    return new Layer(this.__c, p);
+    return __layer(this.__c, p);
   },
   get hasVideo() { return this.__info[8]; },
   get enabled() { return this.__info[11]; },
@@ -804,7 +852,7 @@ Prop.prototype = {
   propertyGroup: function (n) { return __ancestor(this.__c, this.__l, this.__p, n); },
   __wrap: function (v) {
     var kind = this.__info[2];
-    if (kind === 'layer') return v === null ? null : new Layer(this.__c, v);
+    if (kind === 'layer') return v === null ? null : __layer(this.__c, v);
     if (kind === 'path' && v !== null) return new __Path(v[0], v[1], v[2], v[3]);
     return v;
   },
@@ -834,7 +882,7 @@ Prop.prototype = {
     for (var i = 1; i < times.length; i++) if (Math.abs(times[i] - t) < Math.abs(times[best] - t)) best = i;
     return this.key(best + 1);
   },
-  __seedIndex: function () { return this.__self ? __S.idx : new Layer(this.__c, this.__l).index; },
+  __seedIndex: function () { return this.__self ? __S.idx : __layer(this.__c, this.__l).index; },
   wiggle: function (freq, amp, octaves, ampMult, t) {
     if (octaves === undefined) octaves = 1;
     if (ampMult === undefined) ampMult = 0.5;
@@ -903,8 +951,9 @@ var __propHandler = {
     var v = t.value;
     if (v === null || v === undefined) return undefined;
     var x = v[k];
-    // Property groups are callable proxies: hand them over as they are, not bound like methods (#809).
-    if (x?.__isGroup) return x;
+    // Property groups and layers are callable: hand them over as they are, not bound like methods
+    // (#809).
+    if (typeof x === 'function' && (x.__isGroup || x.__isLayer)) return x;
     return typeof x === 'function' ? x.bind(v) : x;
   },
 };
@@ -1082,18 +1131,18 @@ Markers.prototype = {
 // ---------------------------------------------------------------------------------------------
 // Unqualified names: thisLayer / thisProperty attributes and the `this*` objects. They're
 // accessors on the global object; assigning one (`var width = 10`) shadows it for the current
-// evaluation only.
+// evaluation only. They can't be deleted or redefined, so an expression can't take one away from
+// the evaluations after it.
 
 function __global(name, get) {
   Object.defineProperty(globalThis, name, {
-    configurable: true,
     get: function () { return name in __S.vars ? __S.vars[name] : get(); },
     set: function (v) { __S.vars[name] = v; },
   });
 }
 
 __global('thisComp', function () { return __S.comp || (__S.comp = new Comp(__S.c)); });
-__global('thisLayer', function () { return __S.layer || (__S.layer = new Layer(__S.c, __S.l)); });
+__global('thisLayer', function () { return __S.layer || (__S.layer = __layer(__S.c, __S.l)); });
 __global('thisProperty', function () { return __S.prop || (__S.prop = __mkProp(__S.c, __S.l, __S.path)); });
 ['name', 'index', 'inPoint', 'outPoint', 'startTime', 'width', 'height', 'hasParent', 'parent', 'hasVideo', 'enabled', 'active',
   'transform', 'position', 'scale', 'rotation', 'opacity', 'anchorPoint', 'text', 'marker'].forEach(function (k) {
@@ -1226,3 +1275,23 @@ function nearestKey(t) { return thisProperty.nearestKey(t); }
   delete globalThis.Proxy;
   delete globalThis.Reflect;
 })();
+
+// ---------------------------------------------------------------------------------------------
+// The runtime runs this file once and keeps it for the thread's later evaluations, so an
+// expression can't change the object model or the internals: the prototypes are frozen, and the
+// `__` globals, the constructors and `thisProject` can't be reassigned. The `__` state below is
+// set again by `__begin` in each evaluation.
+
+[Comp, Footage, Layer, Prop, Markers, __Path, __TextStyle].forEach(function (f) {
+  Object.freeze(f.prototype);
+  Object.freeze(f);
+});
+[__GroupProto, __groupHandler, __propHandler, thisProject].forEach(Object.freeze);
+(function () {
+  var perEvaluation = { __S: true, __rc: true, __seed: true, __timeless: true, __projectInfo: true };
+  var model = { Comp: true, Footage: true, Layer: true, Prop: true, Markers: true, thisProject: true };
+  Object.getOwnPropertyNames(globalThis).forEach(function (k) {
+    if (!(k.slice(0, 2) === '__' && !perEvaluation[k]) && !model[k]) return;
+    if ('value' in Object.getOwnPropertyDescriptor(globalThis, k)) Object.defineProperty(globalThis, k, { writable: false, configurable: false });
+  });
+})();

crates/expr/src/tests.rs

@@ -77,7 +77,7 @@ fn fx() -> Fx {
 
     let ids = (a.id, b.id, title.id, shape.id);
     let c = p.comp_mut(cid).unwrap();
-    c.layers = vec![a, b, title, shape];
+    c.layers = vec![a, b, title, shape].into();
     c.markers.push(Marker { time: secs(1.5), comment: "comp marker".into(), ..Default::default() });
 
     let other = Comp::new(64, 32, FrameRate::FPS_24, Tick::from_seconds_f64(3.0));
@@ -1099,6 +1099,8 @@ fn shadowing_layer_attribute_names_is_local() {
     let f = fx();
     assert_close!(f.num("var width = 3;\nwidth * 2", 0.0), 6.0);
     assert_close!(f.num("width", 0.0), 20.0, 1e-9);
+    assert_close!(f.num("function width() { return 4; }\nwidth() * 2", 0.0), 8.0);
+    assert_close!(f.num("width", 0.0), 20.0, 1e-9);
 }
 
 #[test]
@@ -1493,4 +1495,97 @@ fn time_to_frames_preserves_coercion_and_small_durations() {
     }
 }
 
+/// A layer is a property group too, as in After Effects: `thisLayer("transform")`, another
+/// layer's `("effects")("Slider Control")` or `(1)`, as the pick whip writes them with Compact
+/// English off (they failed: "not a callable function"). It is still a layer.
+#[test]
+fn layers_are_callable_property_groups() {
+    let f = fx();
+    assert_close!(f.num("thisLayer(\"transform\")(\"opacity\")", 0.0), 100.0);
+    assert_close!(f.num("thisComp.layer(\"A\")(\"effects\")(\"ec.control.slider\")(\"slider\")", 0.0), 42.0);
+    assert_close!(f.num("thisComp.layer(\"A\")(\"effects\")(\"Slider Control\")(1)", 0.0), 42.0);
+    assert_close!(f.num("thisComp.layer(1)(\"effects\")(1)(1)", 0.0), 42.0);
+    // Its own name, index and methods, and a layer as the result still reads as its index.
+    assert_close!(f.num("thisLayer.name == \"A\" ? thisComp.layer(\"B\").index : 0", 0.0), 2.0);
+    assert_close!(f.num("thisComp.layer(\"B\")", 0.0), 2.0);
+    assert_close!(f.num("thisComp.layer(thisComp.layer(\"B\"), -1).index", 0.0), 1.0);
+    assert!(f.err("thisLayer(\"nope\")").contains("no property"), "{}", f.err("thisLayer(\"nope\")"));
+}
+
+/// A layer is kept from one evaluation to the next (it is dear to make) but reads the project
+/// afresh in each, and an expression's own fields on it don't reach the next one.
+#[test]
+fn a_kept_layer_reads_the_project_again() {
+    let mut f = fx();
+    let first = "thisComp.layer(\"B\").index * 10 + thisComp.layer(2).name.length";
+    assert_close!(f.num(first, 0.0), 21.0);
+    f.layer_mut(f.b).name = "Bee".into();
+    f.p.comp_mut(f.cid).unwrap().layers.swap(0, 1);
+    assert_close!(f.num("thisComp.layer(\"Bee\").index * 10 + thisComp.layer(2).name.length", 0.0), 11.0);
+    assert_close!(f.num("thisLayer.index", 0.0), 2.0);
+    let _ = f.ev(f.a, ROT, "thisLayer.mine = 5; 0", 0.0);
+    assert_close!(f.num("thisLayer.mine === undefined ? 1 : 0", 0.0), 1.0);
+    let _ = f.ev(f.a, ROT, "var L = thisLayer; L.__c = 'x'; L.__l = 99; L.__i = ['Z', 7]; L.__s = __S; 0", 0.0);
+    assert_close!(f.num("thisLayer.index * 10 + thisLayer.name.length", 0.0), 21.0);
+    let _ = f.ev(f.a, ROT, "var L = thisLayer; delete L.__c; delete L.__l; delete L.__i; delete L.__s; 0", 0.0);
+    assert_close!(f.num("thisLayer.index * 10 + thisLayer.name.length", 0.0), 21.0);
+    let _ = f.ev(f.a, ROT, "Object.freeze(thisLayer); 0", 0.0);
+    f.layer_mut(f.a).name = "Ay".into();
+    f.p.comp_mut(f.cid).unwrap().layers.swap(0, 1);
+    assert_close!(f.num("thisLayer.index * 10 + thisLayer.name.length", 0.0), 12.0);
+}
+
+/// The kept layers are bounded: past the bound a layer isn't kept, an evaluation that makes more
+/// layers than are kept still sees one object for each layer it had kept, and the evaluations
+/// after it, which start over, read the right layers.
+#[test]
+fn the_kept_layers_are_bounded() {
+    let f = fx();
+    let same = "(thisLayer === thisComp.layer(thisLayer.index) ? 1 : 0)";
+    let many =
+        format!("var c = thisLayer.__c;\nfor (var i = 0; i < 5000; i++) __layer(c, 100000 + i);\n{same} * 10 + (__layer(c, 1e6) === __layer(c, 1e6) ? 0 : 1)");
+    assert_close!(f.num(&many, 0.0), 11.0);
+    assert_close!(f.num(&format!("{same} * 100 + thisLayer.index * 10 + thisLayer.name.length"), 0.0), 111.0);
+    assert_close!(f.num(&format!("{same} * 100 + thisLayer.index * 10 + thisLayer.name.length"), 0.0), 111.0);
+}
+
+/// A change to `Object.prototype` doesn't reach the kept layers: a frozen object put there under
+/// the comp's id, before any of its layers is kept, doesn't stop them being kept.
+#[test]
+fn the_kept_layers_dont_go_through_object_prototype() {
+    let f = fx();
+    let _ = f.ev(f.a, ROT, "try { Object.prototype[thisComp.__c] = Object.freeze({}); } catch (e) {} 0", 0.0);
+    assert_close!(f.num("thisLayer === thisComp.layer(thisLayer.index) ? 1 : 0", 0.0), 1.0);
+}
+
+/// The prelude is kept from one evaluation to the next, so an expression can't change its object
+/// model or internals for the ones after it.
+#[test]
+fn an_expression_cant_change_the_prelude_for_the_next() {
+    let f = fx();
+    let read = "[thisComp.layer(1).index, thisLayer.index, thisLayer('transform').property('rotation').value,                 thisLayer.transform.opacity.value, thisProject.bitsPerChannel, comp(thisComp.name).numLayers, width]";
+    let before = f.ev(f.a, ROT, read, 0.5).unwrap();
+    let attacks = [
+        "Comp.prototype.layer = function () { return 0; }",
+        "Object.getPrototypeOf(thisLayer).index = 0",
+        "Object.getPrototypeOf(thisLayer('transform')).property = function () { return 0; }",
+        "Object.getPrototypeOf(thisLayer.transform.opacity).value = 0",
+        "Comp = function () {}",
+        "Prop = function () {}",
+        "thisProject = null",
+        "__h = function () { return null; }",
+        "__layer = function () { return null; }",
+        "__child = function () {}",
+        "delete __mkProp",
+        "delete thisLayer",
+        "delete thisComp",
+        "delete width",
+        "Object.defineProperty(globalThis, 'thisComp', { get: function () { return 0; } })",
+    ];
+    for a in attacks {
+        let _ = f.ev(f.a, ROT, &format!("try {{ {a} }} catch (e) {{}} 0"), 0.0);
+        assert_eq!(f.ev(f.a, ROT, read, 0.5).unwrap(), before, "after `{a}`");
+    }
+}
+
 mod property_group;

crates/expr/src/tests/property_group.rs

@@ -72,6 +72,9 @@ fn property_group_reaches_the_layer() {
     assert_close!(f.num("thisProperty.propertyGroup(2).name == 'A' ? 1 : 0", 0.0), 1.0);
     assert_close!(f.num("thisProperty.propertyGroup(2).index", 0.0), 1.0);
     assert_close!(f.num("thisProperty.propertyGroup(1).propertyGroup(1).name == 'A' ? 1 : 0", 0.0), 1.0);
+    // The layer it reaches is the same object as `thisLayer`.
+    assert_close!(f.num("thisLayer('transform').propertyGroup(1) === thisLayer ? 1 : 0", 0.0), 1.0);
+    assert_close!(f.num("thisProperty.propertyGroup(2) === thisLayer ? 1 : 0", 0.0), 1.0);
     let s = staggered();
     assert_close!(s.shape_num(SCALE_2, "thisProperty.propertyGroup(4).name == 'Shape' ? 1 : 0"), 1.0);
 }

crates/gpu/src/adv3d.rs

@@ -77,7 +77,7 @@ fn buffer_bytes(count: u64, stride: u64, limit: u64) -> Option<u64> {
 /// Checking these before serialization bounds host packing as well as the GPU uploads.
 fn packed_bytes(counts: [u64; 6], uniform_limit: u64, storage_limit: u64, buffer_limit: u64) -> Option<[u64; 7]> {
     let mut sizes = [0; 7];
-    sizes[0] = buffer_bytes(40, 4, uniform_limit.min(buffer_limit))?;
+    sizes[0] = buffer_bytes(44, 4, uniform_limit.min(buffer_limit))?;
     for (index, (count, stride)) in counts.into_iter().zip([96, 16, 16, 80, 80, 4]).enumerate() {
         let size = count.checked_mul(stride)?.max(16);
         sizes[index + 1] = buffer_bytes(size, 1, storage_limit.min(buffer_limit))?;
@@ -164,11 +164,11 @@ mod capability_tests {
 
     #[test]
     fn packed_arrays_preflight_exact_strides_and_empty_padding() {
-        assert_eq!(packed_bytes([0; 6], 160, 16, 160), Some([160, 16, 16, 16, 16, 16, 16]));
-        assert_eq!(packed_bytes([2; 6], 160, 192, 192), Some([160, 192, 32, 32, 160, 160, 16]));
-        assert!(packed_bytes([0; 6], 159, 16, 160).is_none());
-        assert!(packed_bytes([0; 6], 160, 15, 160).is_none());
-        assert!(packed_bytes([2; 6], 160, 192, 191).is_none());
+        assert_eq!(packed_bytes([0; 6], 176, 16, 176), Some([176, 16, 16, 16, 16, 16, 16]));
+        assert_eq!(packed_bytes([2; 6], 176, 192, 192), Some([176, 192, 32, 32, 160, 160, 16]));
+        assert!(packed_bytes([0; 6], 175, 16, 176).is_none());
+        assert!(packed_bytes([0; 6], 176, 15, 176).is_none());
+        assert!(packed_bytes([2; 6], 176, 192, 191).is_none());
         for index in 0..6 {
             let mut counts = [0; 6];
             counts[index] = u64::MAX;
@@ -203,7 +203,7 @@ mod capability_tests {
         };
         for (scene, counts) in [(Scene::default(), [0; 6]), (scene, [1; 6])] {
             let actual = pack(&scene).map(|bytes| bytes.len() as u64);
-            assert_eq!(Some(actual), packed_bytes(counts, 160, 160, 160));
+            assert_eq!(Some(actual), packed_bytes(counts, 176, 176, 176));
         }
     }
 }
@@ -315,10 +315,25 @@ fn pack(s: &Scene) -> [Vec<u8>; 7] {
     globals.extend([s.eye[0], s.eye[1], s.eye[2], s.ortho as u32 as f32]);
     globals.extend([s.cam_fwd[0], s.cam_fwd[1], s.cam_fwd[2], s.lights.len() as f32]);
     globals.extend([s.ambient[0], s.ambient[1], s.ambient[2], s.env.is_some() as u32 as f32]);
-    let e = s.env.unwrap_or(effectcraft_render::three_d::adv::EnvInfo { radiance: 0, mips: 1, irradiance: 0, intensity: 0.0, rotation: 0.0 });
+    let e = s.env.unwrap_or(effectcraft_render::three_d::adv::EnvInfo {
+        radiance: 0,
+        mips: 1,
+        irradiance: 0,
+        intensity: 0.0,
+        rotation: 0.0,
+        sun: [0.0; 3],
+        key: 0.0,
+        shadow: -1,
+        shadow_darkness: 0.0,
+        shadow_diffusion: 0.0,
+    });
     globals.extend([e.radiance as f32, e.mips as f32, e.irradiance as f32, e.intensity]);
     let lit = !(s.lights.is_empty() && s.env.is_none() && s.ambient == [0.0; 3]);
-    globals.extend([e.rotation, lit as u32 as f32, 0.0, 0.0]);
+    // env2: rotation, any lighting (0/1), shadow map index (-1 none), shadow darkness.
+    globals.extend([e.rotation, lit as u32 as f32, e.shadow as f32, e.shadow_darkness]);
+    // The environment's dominant direction (its shadow's source), for the shadow bias slope,
+    // and its key fraction — how much of its light the shadow can remove (shade::env_shadow).
+    globals.extend([e.sun[0], e.sun[1], e.sun[2], e.key]);
     let mats = s.materials.iter().flat_map(|m| {
         let flags = (m.double_sided as u32)
             | (m.unlit as u32) << 1

crates/gpu/src/effects.rs

@@ -22,6 +22,20 @@ pub(crate) struct GBuf {
 }
 
 impl GBuf {
+    /// [`effectcraft_effects::Buf::cover`] on the device; `None` when it can't hold it.
+    pub fn cover(&mut self, e: &mut Enc, size: [f64; 2]) -> Option<()> {
+        let Some((dx, dy, w, h)) = effectcraft_effects::cover_plan(self.offset, self.scale, size, self.img.width, self.img.height) else { return Some(()) };
+        if !e.g.fits(w, h) {
+            return None;
+        }
+        let out = e.image(w, h);
+        e.copy_into(&self.img, &out, dx, dy);
+        self.img = out;
+        self.offset[0] += dx as f64;
+        self.offset[1] += dy as f64;
+        Some(())
+    }
+
     pub fn to_px(&self, p: [f64; 2]) -> (f64, f64) {
         (p[0] * self.scale + self.offset[0], p[1] * self.scale + self.offset[1])
     }
@@ -167,12 +181,23 @@ impl effectcraft_render::FxTarget for GpuFx<'_, '_> {
     /// GBuf::cover, like `pad`: a bigger texture with the old one copied into place, no
     /// readback. A region the device can't allocate leaves the buffer as it is.
     fn cover(&mut self, size: [f64; 2]) {
+        let Some(mut b) = self.b.take() else { return };
+        let keep = (b.img.clone(), b.offset);
+        if b.cover(self.e, size).is_none() {
+            (b.img, b.offset) = keep;
+        }
+        self.b = Some(b);
+    }
+
+    /// [`effectcraft_effects::Buf::align`] on the device: a texture grown left/top, the old one
+    /// copied in. A size the device can't allocate leaves the buffer as it is.
+    fn align(&mut self, size: [f64; 2]) {
         let Some(b) = self.b.take() else { return };
-        let out = match effectcraft_effects::cover_plan(b.offset, b.scale, size, b.img.width, b.img.height) {
-            Some((dx, dy, w, h)) if self.e.g.fits(w, h) => {
-                let img = self.e.image(w, h);
-                self.e.copy_into(&b.img, &img, dx, dy);
-                GBuf { img, offset: [b.offset[0] + dx as f64, b.offset[1] + dy as f64], scale: b.scale }
+        let out = match effectcraft_effects::align_plan(b.offset, b.scale, size, b.img.width, b.img.height) {
+            Some((l, t)) if self.e.g.fits(b.img.width + l, b.img.height + t) => {
+                let img = self.e.image(b.img.width + l, b.img.height + t);
+                self.e.copy_into(&b.img, &img, l, t);
+                GBuf { img, offset: [b.offset[0] + l as f64, b.offset[1] + t as f64], scale: b.scale }
             }
             _ => b,
         };
@@ -292,6 +317,9 @@ fn gaussian(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
     let repeat = ctx.params.b("repeatEdge");
     if !repeat && !ctx.adjustment {
         b.pad(e, (s * 3.0).ceil() as u32)?;
+    } else if repeat && !ctx.adjustment {
+        // The edge it repeats is the layer's, not the painted content's (#1205).
+        b.cover(e, ctx.layer_size)?;
     }
     b.img = gaussian_blur(e, &b.img, s * kx, s * ky, repeat || ctx.adjustment);
     Some(b)
@@ -312,6 +340,9 @@ fn box_blur(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
     let repeat = ctx.params.b("repeatEdge");
     if !repeat && !ctx.adjustment {
         b.pad(e, (r * it) as u32 + 1)?;
+    } else if repeat && !ctx.adjustment {
+        // The edge it repeats is the layer's, not the painted content's (#1205).
+        b.cover(e, ctx.layer_size)?;
     }
     b.img = box_passes(e, &b.img, &vec![r * kx as usize; it], &vec![r * ky as usize; it], repeat || ctx.adjustment);
     Some(b)

crates/gpu/src/fx_distort.rs

@@ -180,6 +180,9 @@ fn turbulent(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
     let size = (ctx.params.f("size") * b.scale).max(1.0);
     if ctx.params.b("resizeLayer") && !ctx.adjustment {
         b.pad(e, amount.abs().ceil() as u32 + 1)?;
+    } else {
+        // Room for pixels displaced past the content, up to the layer's edge (#1205).
+        b.pad(e, effectcraft_effects::cover_pad(ctx, [b.img.width, b.img.height], b.offset, b.scale, amount.abs().ceil() as u32 + 1))?;
     }
     let off = b.to_px(ctx.params.v2("offset"));
     let oct = ctx.params.f("complexity").clamp(1.0, 10.0);

crates/gpu/src/shaders/advanced3d.wgsl

@@ -14,8 +14,10 @@ struct Globals {
     ambient: vec4<f32>,
     // radiance first texture, mip count, irradiance texture, intensity
     env: vec4<f32>,
-    // rotation, any lighting (0/1), -, -
+    // rotation, any lighting (0/1), shadow map index (-1 none), shadow darkness
     env2: vec4<f32>,
+    // the environment's dominant direction (its shadow's source)
+    env_sun: vec4<f32>,
 };
 
 @group(0) @binding(0) var<uniform> g: Globals;
@@ -339,6 +341,18 @@ fn light_shadow(li: u32, kind: u32, lpos: vec3<f32>, shadow: i32, darkness: f32,
     return 1.0 - darkness * (1.0 - f);
 }
 
+// The Environment light's shadow from its dominant direction (shade::env_shadow). Only the
+// image's key fraction (g.env_sun.w) of the light is occluded — the fill keeps shining — so
+// the shadow stays partial the way After Effects renders an area-light shadow.
+fn env_shadow(p: vec3<f32>, ng: vec3<f32>, n: vec3<f32>) -> f32 {
+    if (g.env2.z < 0.0) {
+        return 1.0;
+    }
+    let n_l = clamp(dot(n, g.env_sun.xyz), 0.0, 1.0);
+    let f = shadow_factor(u32(g.env2.z + 0.5) * SHADOW_STRIDE, p, ng, n_l);
+    return 1.0 - g.env2.w * g.env_sun.w * (1.0 - f);
+}
+
 fn attenuation(kind: u32, falloff: u32, radius: f32, falloff_distance: f32, cos_inner: f32, cos_outer: f32, dir: vec3<f32>, to_l: vec3<f32>, dist: f32) -> f32 {
     var k = 1.0;
     if (falloff == 1u && kind != 0u) {
@@ -425,6 +439,10 @@ fn shadow_only_amount(unlit: bool, normal: vec3<f32>, front: bool, pos: vec3<f32
         }
         amount = max(amount, 1.0 - light_shadow(li, kind, l0.xyz, i32(l3.w), l4.x, pos, n, n_l));
     }
+    // The Environment light's shadow counts too (it reaches every surface: no falloff).
+    if (g.ambient.w > 0.5) {
+        amount = max(amount, 1.0 - env_shadow(pos, n, n));
+    }
     return amount;
 }
 
@@ -564,7 +582,11 @@ fn fs(i: VOut, @builtin(front_facing) front: bool) -> FOut {
         let f0 = mix(vec3<f32>(0.04 * spec_k), rgb, metallic);
         let ab = env_brdf(n_v, rough);
         let fs = f0 * ab.x + vec3<f32>(ab.y);
-        acc = acc + (irr * rgb * (vec3<f32>(1.0) - fs) * (1.0 - metallic) * diff_k + spec * fs) * ao;
+        var esh = 1.0;
+        if (receives_shadows) {
+            esh = env_shadow(i.pos, ng, n);
+        }
+        acc = acc + (irr * rgb * (vec3<f32>(1.0) - fs) * (1.0 - metallic) * diff_k + spec * fs) * ao * esh;
     }
     let c = acc + emissive;
     out.color = vec4<f32>(c * alpha, alpha);

crates/gpu/src/shaders/fx_sim.wgsl

@@ -180,7 +180,7 @@ fn fxm_bubble(at: u32, x: f32, y: f32) -> FxmShade {
     }
     let k = select(-0.7, 1.6, P.u[1].y != 0u);
     let nz = sqrt(max(1.0 - d2, 0.0));
-    let s = fxm_unpremul(sample_bilinear(src, data[at + 4u] + dx * qr * k, data[at + 5u] + dy * qr * k));
+    let s = fxm_unpremul(sample_bilinear_clamped(src, data[at + 4u] + dx * qr * k, data[at + 5u] + dy * qr * k));
     var c = s.xyz;
     if (s.w <= 0.0) {
         c = vec3<f32>(0.6, 0.7, 0.8);

crates/gpu/src/tests.rs

@@ -498,7 +498,7 @@ fn layer_styles_collapsed_precomps_and_cpu_fallbacks() {
             b.blend_mode = BlendMode::Difference;
             (a, b)
         };
-        s.p.comp_mut(inner_id).unwrap().layers = vec![b, a];
+        s.p.comp_mut(inner_id).unwrap().layers = vec![b, a].into();
         let bg = s.footage(97, 61);
         s.push(bg);
         let mut pre = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (60, 40), None);

crates/gpu/src/tests/adjust.rs

@@ -83,7 +83,7 @@ fn track_mattes_limit_gpu_adjustments_like_the_cpu() {
             set(&mut matte, "transform/rotation", Value::Scalar(10.0));
             let mid = s.push(matte);
             let c = s.p.comp_mut(s.cid).unwrap();
-            let adj = c.layers.iter_mut().find(|l| l.switches.adjustment).unwrap();
+            let adj = c.layers.find_mut(|l| l.switches.adjustment).unwrap();
             adj.track_matte = Some(TrackMatte { layer: mid, kind });
             check(&format!("matted adjustment {kind:?} {depth:?}"), compare_at(&s, opts(), Tick::ZERO), 0.0);
         }

crates/gpu/src/tests/adv3d.rs

@@ -5,7 +5,7 @@
 //! edges may be covered by the other neighbour. Interior pixels agree within 2/255; at most
 //! 1.5 % of pixels (silhouettes) may differ more. Skipped without an adapter.
 
-use effectcraft_keyframe::Value;
+use effectcraft_keyframe::{Gradient, Value};
 use effectcraft_project::build;
 use effectcraft_project::{Comp, ItemId, ItemKind, LayerSource, LightKind, PrimitiveKind, Project, Renderer as R3, Solid};
 use effectcraft_render::three_d::adv::{self, Scene};
@@ -38,7 +38,8 @@ fn set(l: &mut effectcraft_project::Layer, path: &str, v: Value) {
 }
 
 /// Primitives with metal/dielectric materials, a shadow-casting spot light and a point light,
-/// an environment light, a semi-transparent textured card.
+/// a shadow-casting Environment light over a sky-gradient environment layer, a semi-transparent
+/// textured card.
 pub(crate) fn scene_project() -> (Project, ItemId) {
     let mut p = Project::default();
     let mut c = Comp::new(240, 160, FrameRate::FPS_30, Tick::from_seconds_f64(1.0));
@@ -73,12 +74,29 @@ pub(crate) fn scene_project() -> (Project, ItemId) {
         set(l, "transform/position", Value::Vec3([120.0, 80.0, -60.0]));
         set(l, "transform/rotationY", Value::Scalar(30.0));
     });
-    let env = p.add_item("E", Default::default(), None, ItemKind::Solid(Solid { color: [0.6, 0.7, 1.0], width: 32, height: 16, pixel_aspect: 1.0 }));
-    add(&mut p, cid, LayerSource::Solid { item: env }, |l| {
-        l.environment = true;
+    // The Environment Layer: a sky-to-ground gradient (its dominant region, the bright sky,
+    // shadows the scene from above).
+    add(&mut p, cid, LayerSource::Shape, |l| {
         l.switches.three_d = true;
+        let mut next = 10_000u64;
+        let ids = &mut build::Ids(&mut next);
+        let rect = build::shape_rect(ids, [240.0, 160.0], [0.0, 0.0], 0.0);
+        let gfill = build::shape_gradient_fill(
+            ids,
+            false,
+            [0.0, -80.0],
+            [0.0, 80.0],
+            Gradient { colors: vec![(0.0, [1.0, 1.0, 1.0, 1.0]), (1.0, [0.04, 0.05, 0.08, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 1.0)] },
+        );
+        let g = build::shape_group(ids, "Sky", vec![rect, gfill]);
+        l.props.sub_mut("contents").unwrap().children.push(g.into());
+        l.environment = true;
+    });
+    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |l| {
+        set(l, "lightOptions/intensity", Value::Scalar(50.0));
+        set(l, "lightOptions/castsShadows", Value::Bool(true));
+        set(l, "lightOptions/shadowDiffusion", Value::Scalar(6.0));
     });
-    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |l| set(l, "lightOptions/intensity", Value::Scalar(50.0)));
     add(&mut p, cid, LayerSource::Light { kind: LightKind::Spot }, |l| {
         set(l, "transform/position", Value::Vec3([40.0, -120.0, -200.0]));
         set(l, "transform/poi", Value::Vec3([120.0, 100.0, 0.0]));
@@ -144,6 +162,8 @@ fn gpu_matches_cpu_lit_scene() {
     let (p, cid) = scene_project();
     let s = scene(&p, cid);
     assert!(!s.shadows.is_empty() && s.env.is_some() && s.opaque_count < s.indices.len() as u32);
+    // The Environment light casts its shadow (the sky gradient's dominant direction).
+    assert!(s.env.is_some_and(|e| e.shadow >= 0 && e.sun != [0.0; 3]), "the environment shadow map is built");
     compare(&s, &g);
 }
 
@@ -190,7 +210,7 @@ fn gpu_matches_cpu_wide_penumbrae() {
     set(&mut comp.layers[0], "lightOptions/shadowDiffusion", Value::Scalar(30.0));
     let s = scene(&p, cid);
     let (cpu, gt) = (adv::raster::render(&s), g.raster_3d(&s).expect("gpu raster"));
-    for l in &mut p.comp_mut(cid).unwrap().layers[..2] {
+    for l in p.comp_mut(cid).unwrap().layers.iter_mut().take(2) {
         set(l, "lightOptions/castsShadows", Value::Bool(false));
     }
     let unshadowed = adv::raster::render(&scene(&p, cid));
@@ -260,7 +280,7 @@ pub(crate) fn dof_mb_project() -> (Project, ItemId) {
     c.enable_motion_blur = true;
     c.motion_blur_samples = 6;
     // The sphere moves 40 px per frame.
-    let sphere = c.layers.iter_mut().find(|l| matches!(l.source, LayerSource::Primitive { kind: PrimitiveKind::Sphere })).unwrap();
+    let sphere = c.layers.find_mut(|l| matches!(l.source, LayerSource::Primitive { kind: PrimitiveKind::Sphere })).unwrap();
     sphere.switches.motion_blur = true;
     sphere.props.prop_mut("transform/position").unwrap().keys = vec![
         effectcraft_keyframe::Keyframe::new(Tick::ZERO, Value::Vec3([80.0, 95.0, 0.0])),
@@ -429,7 +449,7 @@ fn gpu_compositor_draws_advanced_3d_runs_on_the_device() {
     eprintln!("walk: {:.3} % beyond 1/255 (max {max:.4})", share * 100.0);
     assert!(share <= 0.01, "{:.3} % of pixels differ", share * 100.0);
     // A blend mode in the run takes the 2D compositing path (`SplitRun`, also on the GPU).
-    p.comp_mut(cid).unwrap().layers.iter_mut().find(|l| l.switches.three_d && !l.is_light() && l.source.is_av()).unwrap().blend_mode =
+    p.comp_mut(cid).unwrap().layers.find_mut(|l| l.switches.three_d && !l.is_light() && l.source.is_av()).unwrap().blend_mode =
         effectcraft_color::BlendMode::Screen;
     let (ctx, run) = run_of(&p, cid);
     assert!(Renderer::new(&p, &NoFootage, RenderOpts::default()).prepare_adv_run(&ctx, &run, (240, 160)).is_none());
@@ -550,12 +570,12 @@ fn gpu_compositor_draws_split_advanced_3d_runs_and_skies() {
             });
         }
         let c = p.comp_mut(cid).unwrap();
-        let env = c.layers.iter_mut().find(|l| l.environment).unwrap();
+        let env = c.layers.find_mut(|l| l.environment).unwrap();
         env.props.sub_mut("effects").unwrap().children.push(ramp.into());
         let ids: Vec<_> = c.layers.iter().filter(|l| l.switches.three_d && !l.is_light() && !l.environment && l.source.is_av()).map(|l| l.id).collect();
         let top = c.layers[0].id;
         fn by_id(c: &mut Comp, id: effectcraft_project::LayerId) -> &mut effectcraft_project::Layer {
-            c.layers.iter_mut().find(|l| l.id == id).unwrap()
+            c.layers.find_mut(|l| l.id == id).unwrap()
         }
         match case {
             0 => by_id(c, ids[1]).blend_mode = effectcraft_color::BlendMode::Screen,
@@ -573,7 +593,7 @@ fn gpu_compositor_draws_split_advanced_3d_runs_and_skies() {
             }
             _ => {
                 // An environment background behind the run, and the 2D track matte.
-                c.layers.iter_mut().find(|l| l.environment).unwrap().environment_background = true;
+                c.layers.find_mut(|l| l.environment).unwrap().environment_background = true;
                 by_id(c, ids[0]).track_matte = Some(effectcraft_project::TrackMatte { layer: top, kind: effectcraft_project::MatteKind::Alpha });
             }
         }

crates/gpu/src/tests/fx_noise.rs

@@ -208,7 +208,7 @@ fn echo_and_posterize_time() {
             pos.keys = vec![Keyframe::new(Tick::ZERO, crate::tests::v3(10.0, 12.0)), Keyframe::new(Tick::from_seconds_f64(1.0), crate::tests::v3(50.0, 30.0))];
             let rot = a.props.prop_mut("transform/rotation").unwrap();
             rot.keys = vec![Keyframe::new(Tick::ZERO, Value::Scalar(0.0)), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Scalar(90.0))];
-            s.p.comp_mut(inner_id).unwrap().layers = vec![a];
+            s.p.comp_mut(inner_id).unwrap().layers = vec![a].into();
             let mut l = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (60, 40), None);
             s.effect(&mut l, id, &vals);
             set(&mut l, "transform/rotation", Value::Scalar(8.0));

crates/gpu/src/tests/fx_time.rs

@@ -40,7 +40,7 @@ fn moving(id: &str, vals: &[(&str, Value)], map: Option<&str>) {
         pos.keys = vec![Keyframe::new(Tick::ZERO, v3(10.0, 12.0)), Keyframe::new(Tick::from_seconds_f64(1.0), v3(50.0, 30.0))];
         let rot = a.props.prop_mut("transform/rotation").unwrap();
         rot.keys = vec![Keyframe::new(Tick::ZERO, Value::Scalar(0.0)), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Scalar(90.0))];
-        s.p.comp_mut(inner_id).unwrap().layers = vec![a];
+        s.p.comp_mut(inner_id).unwrap().layers = vec![a].into();
         let mut l = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (60, 40), None);
         s.effect(&mut l, id, &vals);
         set(&mut l, "transform/rotation", Value::Scalar(8.0));

crates/gpu/src/tests/fx_tone.rs

@@ -164,7 +164,7 @@ fn color_stabilizer() {
             pos.keys = vec![Keyframe::new(Tick::ZERO, crate::tests::v3(22.0, 18.0)), Keyframe::new(Tick::from_seconds_f64(1.0), crate::tests::v3(38.0, 24.0))];
             let op = a.props.prop_mut("transform/opacity").unwrap();
             op.keys = vec![Keyframe::new(Tick::ZERO, Value::Scalar(100.0)), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Scalar(40.0))];
-            s.p.comp_mut(inner_id).unwrap().layers = vec![a];
+            s.p.comp_mut(inner_id).unwrap().layers = vec![a].into();
             let mut l = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (60, 40), None);
             let vals = [
                 ("stabilize", e(mode)),

crates/gpu/src/tests/three_d.rs

@@ -177,7 +177,7 @@ fn mattes_preserve_transparency_precomps_and_adjustment_splits() {
         let mid = s.push(m);
         let layers = &mut s.p.comp_mut(s.cid).unwrap().layers;
         layers[1].track_matte = Some(TrackMatte { layer: mid, kind: MatteKind::Luma });
-        if let Some(far) = layers.iter_mut().find(|l| l.switches.three_d && l.name == "Pattern") {
+        if let Some(far) = layers.find_mut(|l| l.switches.three_d && l.name == "Pattern") {
             far.preserve_transparency = true;
         }
         // Move the matte below the bottom so the 3D run stays one run.
@@ -203,7 +203,7 @@ fn mattes_preserve_transparency_precomps_and_adjustment_splits() {
         a.switches.three_d = true;
         set(&mut a, "transform/rotationX", Value::Scalar(40.0));
         let b = s.solid([0.2, 0.8, 0.4], 30, 20);
-        s.p.comp_mut(inner_id).unwrap().layers = vec![b, a];
+        s.p.comp_mut(inner_id).unwrap().layers = vec![b, a].into();
         let mut pre = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (80, 60), None);
         pre.switches.collapse = true;
         pre.switches.three_d = true;
@@ -299,7 +299,7 @@ fn two_d_layer_with_a_three_d_track_matte() {
             let layers = &mut s.p.comp_mut(s.cid).unwrap().layers;
             let fi = layers.iter().position(|l| l.id == fid).unwrap();
             layers[fi].track_matte = Some(TrackMatte { layer: mid, kind });
-            if let Some(ml) = layers.iter_mut().find(|l| l.id == mid) {
+            if let Some(ml) = layers.find_mut(|l| l.id == mid) {
                 ml.switches.video = false;
             }
             check(&format!("3d matte {kind:?} {depth:?}"), compare_at(&s, opts(), Tick::ZERO), 0.005);

crates/host/tests/it/vector_import.rs

@@ -509,7 +509,7 @@ fn shapes_from_vector_layer_keeps_images_as_footage_layers() {
     assert_eq!(names, ["images.pdf Outlines", "Image", "Image", "images.pdf Outlines 1", "images.pdf"]);
     assert_eq!(c.layers[0].id.0, sid);
     assert_eq!(r["layers"].as_array().unwrap().len(), 2);
-    for l in &c.layers[1..3] {
+    for l in c.layers.iter().skip(1).take(2) {
         assert_eq!(l.parent.map(|p| p.0), Some(sid), "{}", l.name);
         assert!(matches!(l.source, effectcraft_project::LayerSource::Footage { .. }));
     }

crates/interchange/src/export.rs

@@ -155,12 +155,7 @@ fn unsupported(project: &Project, comp: &Comp, l: &Layer, format: TimelineFormat
         return Some(format!("blend mode {}", l.blend_mode.label()));
     }
     // Premiere's Basic Motion in the interchange formats has one (uniform) scale.
-    if let Some(s) = l.transform().and_then(|t| t.get("scale"))
-        && std::iter::once(&s.value).chain(s.keys.iter().map(|k| &k.value)).any(|v| {
-            let a = v.as_vec3();
-            (a[0] - a[1]).abs() > 1e-9
-        })
-    {
+    if l.transform().and_then(|t| t.get("scale")).is_some_and(non_uniform_scale) {
         return Some("non-uniform scale".into());
     }
     if l.preserve_transparency {
@@ -581,10 +576,7 @@ impl Exporter<'_> {
             }
         }
         if let Some(p) = tr.get("scale") {
-            let uniform = std::iter::once(&p.value).chain(p.keys.iter().map(|k| &k.value)).all(|v| {
-                let a = v.as_vec3();
-                (a[0] - a[1]).abs() < 1e-9
-            });
+            let uniform = !non_uniform_scale(p);
             m.params.insert("scale".into(), param_out(p, &to_clip, |v| fp::ParamValue::Float(v.as_vec3()[1])));
             if !uniform {
                 m.params.insert("scale_width".into(), param_out(p, &to_clip, |v| fp::ParamValue::Float(v.as_vec3()[0])));
@@ -636,6 +628,16 @@ fn differs(v: &Value, def: [f64; 2]) -> bool {
     (a[0] - def[0]).abs() > 1e-6 || (a[1] - def[1]).abs() > 1e-6
 }
 
+/// Whether a scale property is non-uniform at some point: active key values, or the static
+/// value when every key is muted (muted keys are not exported, #1894).
+fn non_uniform_scale(p: &Property) -> bool {
+    let non_uniform = |v: &Value| {
+        let a = v.as_vec3();
+        (a[0] - a[1]).abs() > 1e-9
+    };
+    if p.keys.iter().any(|k| !k.muted) { p.keys.iter().filter(|k| !k.muted).any(|k| non_uniform(&k.value)) } else { non_uniform(&p.value) }
+}
+
 /// The clip's `id` effect, or a new instance of it (None if the registry has no such effect).
 fn effect_or_new(ti: &fp::TrackItem, id: &str) -> Option<fp::EffectInstance> {
     ti.effect(id).cloned().or_else(|| fp::find_effect(id).map(|e| e.instance()))
@@ -651,7 +653,9 @@ fn set_effect(ti: &mut fp::TrackItem, e: fp::EffectInstance) {
 /// A property → a FilmCraft parameter (layer-time keys → clip-time keys).
 fn param_out(p: &Property, to_clip: &impl Fn(Tick) -> filmcraft_time::Tick, conv: impl Fn(&Value) -> fp::ParamValue) -> fp::Param {
     let mut out = fp::Param::new(conv(&p.value));
-    for k in &p.keys {
+    // XML timelines have no mute state: leave muted keys out, as the Lottie exporter does, so
+    // the exported animation matches what the renderer shows (#1894).
+    for k in p.keys.iter().filter(|k| !k.muted) {
         let mut fk = fp::Keyframe::new(to_clip(k.time), conv(&k.value));
         fk.interp = match k.out_interp {
             Interp::Linear => fp::Interpolation::Linear,

crates/interchange/src/tests.rs

@@ -415,7 +415,7 @@ fn ae_project() -> (Project, ItemId) {
     let mut ls = effectcraft_project::build::layer(&mut p, &c, "tone", LayerSource::Footage { item: s }, (0, 0), None);
     ls.out_point = t(3.0);
     ls.props.prop_mut("audio/levels").unwrap().value = Value::Vec2([-3.0, -3.0]);
-    c.layers = vec![lt, lp, la, ls];
+    c.layers = vec![lt, lp, la, ls].into();
     let cid = comp_item(&mut p, "Main", c);
     (p, cid)
 }
@@ -484,6 +484,59 @@ fn tr_orig(l: &Layer) -> &effectcraft_project::Property {
     l.transform().unwrap().get("position").unwrap()
 }
 
+/// #1894: XML timelines have no mute state, so a muted key must not be written as a keyframe
+/// (the export would otherwise animate through it).
+#[test]
+fn export_skips_muted_keyframes() {
+    let mut p = Project::default();
+    let a = footage_item(&mut p, "/media/a.mov");
+    let mut c = Comp::new(W, H, FrameRate::new(25, 1), t(4.0));
+    let mut l = effectcraft_project::build::layer(&mut p, &c, "clip", LayerSource::Footage { item: a }, (W, H), None);
+    {
+        let pos = l.transform_mut().unwrap().get_mut("position").unwrap();
+        pos.keys = vec![
+            Keyframe::new(t(0.0), Value::Vec3([100.0, 120.0, 0.0])),
+            Keyframe::new(t(1.0), Value::Vec3([500.0, 240.0, 0.0])),
+            Keyframe::new(t(2.0), Value::Vec3([300.0, 60.0, 0.0])),
+        ];
+        pos.keys[1].muted = true;
+    }
+    c.layers.push(l);
+    let cid = comp_item(&mut p, "Main", c);
+    let out = export(&p, cid, &ExportOptions { format: TimelineFormat::Fcp7Xml, ..Default::default() }, &HashMap::new()).unwrap();
+    let (q, r) = import_doc(&out.bytes, "Main.xml", &mut probe);
+    let main = r.comps.iter().copied().find(|c| q.item(*c).unwrap().name == "Main").expect("Main");
+    let pos = layer(q.comp(main).unwrap(), "clip").transform().unwrap().get("position").unwrap();
+    assert_eq!(pos.keys.len(), 2, "the muted key was exported");
+    assert_eq!(pos.keys[0].value.as_vec3()[0], 100.0);
+    assert_eq!(pos.keys[1].value.as_vec3()[0], 300.0);
+}
+
+/// #1894: a muted non-uniform scale key must not force a uniform layer to pre-render; only the
+/// active keys matter, and the static value when every key is muted.
+#[test]
+fn muted_non_uniform_scale_does_not_force_prerendering() {
+    let mut p = Project::default();
+    let a = footage_item(&mut p, "/media/a.mov");
+    let mut c = Comp::new(W, H, FrameRate::new(25, 1), t(2.0));
+    let mut l = effectcraft_project::build::layer(&mut p, &c, "clip", LayerSource::Footage { item: a }, (W, H), None);
+    {
+        let scale = l.transform_mut().unwrap().get_mut("scale").unwrap();
+        scale.keys = vec![Keyframe::new(t(0.0), Value::Vec3([100.0, 100.0, 100.0])), Keyframe::new(t(1.0), Value::Vec3([50.0, 200.0, 100.0]))];
+        scale.keys[1].muted = true;
+    }
+    let lid = l.id;
+    c.layers.push(l);
+    let cid = comp_item(&mut p, "Main", c);
+    assert_eq!(prerender_reason(&p, cid, lid, &ExportOptions::default()), None);
+    // With every key muted the static value drives evaluation, so a non-uniform static scale
+    // still takes the flattened path.
+    let scale = p.comp_mut(cid).unwrap().layer_mut(lid).unwrap().transform_mut().unwrap().get_mut("scale").unwrap();
+    scale.keys[0].muted = true;
+    scale.value = Value::Vec3([50.0, 200.0, 100.0]);
+    assert_eq!(prerender_reason(&p, cid, lid, &ExportOptions::default()).as_deref(), Some("non-uniform scale"));
+}
+
 #[test]
 fn export_without_prerender_leaves_text_out() {
     let (p, cid) = ae_project();

crates/keyframe/src/lib.rs

@@ -15,6 +15,7 @@ pub mod value;
 
 use effectcraft_time::{TICKS_PER_SECOND, Tick};
 use serde::{Deserialize, Serialize};
+use std::borrow::Borrow;
 pub use text_doc::{BaselineOption, CharStyle, Composer, Direction, FigureStyle, FigureWidth, Kerning, LineJoin, OpenType, ParaStyle, StyleRun};
 pub use value::{FeatherPoint, Gradient, Justify, ShapePath, TextDoc, Value};
 
@@ -89,12 +90,19 @@ pub struct Keyframe {
     /// Keyframe color label: index into the label list (0 = None).
     #[serde(default, skip_serializing_if = "is_zero")]
     pub label: u8,
+    /// Muted keys stay in the list (and the UI) but evaluation skips them.
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub muted: bool,
 }
 
 fn is_zero(v: &u8) -> bool {
     *v == 0
 }
 
+fn is_false(v: &bool) -> bool {
+    !*v
+}
+
 fn yes() -> bool {
     true
 }
@@ -116,6 +124,7 @@ impl Keyframe {
             spatial_continuous: false,
             roving: false,
             label: 0,
+            muted: false,
         }
     }
     pub fn hold(mut self) -> Keyframe {
@@ -320,16 +329,16 @@ fn v3(v: &Value) -> [f64; 3] {
 /// tangent is a sixth of the way from the previous key to the next, the in tangent its mirror, and
 /// key times play no part. An end key uses its one neighbour, so the path leaves the first key
 /// and enters the last one toward the neighbouring key instead of with no tangent.
-fn auto_spatial(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
+fn auto_spatial<K: Borrow<Keyframe>>(keys: &[K], i: usize) -> ([f64; 3], [f64; 3]) {
     if i >= keys.len() || keys.len() < 2 {
         return ([0.0; 3], [0.0; 3]);
     }
-    let a = v3(&keys[i.saturating_sub(1)].value);
-    let c = v3(&keys[(i + 1).min(keys.len() - 1)].value);
+    let a = v3(&keys[i.saturating_sub(1)].borrow().value);
+    let c = v3(&keys[(i + 1).min(keys.len() - 1)].borrow().value);
     let tout = [(c[0] - a[0]) / 6.0, (c[1] - a[1]) / 6.0, (c[2] - a[2]) / 6.0];
     // A side facing a key at the same position gets no tangent, so the segment between two
     // identical keys has zero length and the layer holds still (#1675).
-    let p = v3(&keys[i].value);
+    let p = v3(&keys[i].borrow().value);
     let tin = if i > 0 && a == p { [0.0; 3] } else { [-tout[0], -tout[1], -tout[2]] };
     let tout = if i + 1 < keys.len() && c == p { [0.0; 3] } else { tout };
     (tin, tout)
@@ -337,7 +346,12 @@ fn auto_spatial(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
 
 /// Effective spatial tangents of key `i` (auto or stored).
 pub fn spatial_tangents(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
-    let Some(key) = keys.get(i) else { return ([0.0; 3], [0.0; 3]) };
+    tangents_of(keys, i)
+}
+
+/// [`spatial_tangents`] over stored keys or a filtered list of them (see [`evaluate`]).
+fn tangents_of<K: Borrow<Keyframe>>(keys: &[K], i: usize) -> ([f64; 3], [f64; 3]) {
+    let Some(key) = keys.get(i).map(Borrow::borrow) else { return ([0.0; 3], [0.0; 3]) };
     if key.spatial_auto { auto_spatial(keys, i) } else { (key.spatial_in, key.spatial_out) }
 }
 
@@ -373,18 +387,18 @@ pub fn spatial_handles(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
 }
 
 /// Effective temporal ease of key `i` for dimension `d` (auto-Bezier keys get the neighbour slope).
-fn effective_ease(keys: &[Keyframe], i: usize, d: usize, spatial: bool, out: bool) -> Ease {
-    let k = &keys[i];
+fn effective_ease<K: Borrow<Keyframe>>(keys: &[K], i: usize, d: usize, spatial: bool, out: bool) -> Ease {
+    let k = keys[i].borrow();
     let list = if out { &k.out_ease } else { &k.in_ease };
     if k.auto_bezier && i > 0 && i + 1 < keys.len() {
-        let dt = secs(keys[i + 1].time) - secs(keys[i - 1].time);
+        let dt = secs(keys[i + 1].borrow().time) - secs(keys[i - 1].borrow().time);
         let slope = if spatial {
-            let a = v3(&keys[i - 1].value);
-            let c = v3(&keys[i + 1].value);
+            let a = v3(&keys[i - 1].borrow().value);
+            let c = v3(&keys[i + 1].borrow().value);
             ((c[0] - a[0]).powi(2) + (c[1] - a[1]).powi(2) + (c[2] - a[2]).powi(2)).sqrt() / dt.max(1e-12)
         } else {
-            let a = keys[i - 1].value.components();
-            let c = keys[i + 1].value.components();
+            let a = keys[i - 1].borrow().value.components();
+            let c = keys[i + 1].borrow().value.components();
             (c.get(d).unwrap_or(&0.0) - a.get(d).unwrap_or(&0.0)) / dt.max(1e-12)
         };
         return Ease { speed: slope, influence: 1.0 / 6.0 };
@@ -508,23 +522,39 @@ pub fn time_reverse(keys: &mut [Keyframe]) {
 }
 
 /// Evaluate a keyframed property at `t`. `spatial` selects motion-path semantics for 2D/3D values.
+/// Muted keys are skipped, so the active neighbours interpolate as if they were not there; `None`
+/// means every key is muted (the property's static value applies).
 pub fn evaluate(keys: &[Keyframe], t: Tick, spatial: bool) -> Option<Value> {
-    let first = keys.first()?;
+    if !keys.iter().any(|k| k.muted) {
+        return evaluate_active(keys, t, spatial);
+    }
+    // Muting is rare: skip the muted keys by reference rather than copying every key and value.
+    let active: Vec<&Keyframe> = keys.iter().filter(|k| !k.muted).collect();
+    evaluate_active(&active, t, spatial)
+}
+
+fn evaluate_active<K: Borrow<Keyframe>>(keys: &[K], t: Tick, spatial: bool) -> Option<Value> {
+    let first = keys.first()?.borrow();
     if keys.len() == 1 || t <= first.time {
         return Some(first.value.clone());
     }
-    let last = keys.last()?;
+    let last = keys.last()?.borrow();
     if t >= last.time {
         return Some(last.value.clone());
     }
-    let i = keys.partition_point(|k| k.time <= t) - 1;
-    Some(segment_value(keys, i, t, spatial))
+    let i = keys.partition_point(|k| k.borrow().time <= t) - 1;
+    Some(segment_value_of(keys, i, t, spatial))
 }
 
 /// Value inside segment `i` → `i+1` at time `t`.
 pub fn segment_value(keys: &[Keyframe], i: usize, t: Tick, spatial: bool) -> Value {
-    let a = &keys[i];
-    let b = &keys[i + 1];
+    segment_value_of(keys, i, t, spatial)
+}
+
+/// [`segment_value`] over stored keys or a filtered list of them (see [`evaluate`]).
+fn segment_value_of<K: Borrow<Keyframe>>(keys: &[K], i: usize, t: Tick, spatial: bool) -> Value {
+    let a = keys[i].borrow();
+    let b = keys[i + 1].borrow();
     if a.out_interp == Interp::Hold || !a.value.interpolates() {
         return a.value.clone();
     }
@@ -539,8 +569,8 @@ pub fn segment_value(keys: &[Keyframe], i: usize, t: Tick, spatial: bool) -> Val
     if is_spatial {
         let p0 = v3(&a.value);
         let p3 = v3(&b.value);
-        let (_, out_t) = spatial_tangents(keys, i);
-        let (in_t, _) = spatial_tangents(keys, i + 1);
+        let (_, out_t) = tangents_of(keys, i);
+        let (in_t, _) = tangents_of(keys, i + 1);
         let seg = SpatialSeg::new([p0, [p0[0] + out_t[0], p0[1] + out_t[1], p0[2] + out_t[2]], [p3[0] + in_t[0], p3[1] + in_t[1], p3[2] + in_t[2]], p3]);
         let len = seg.length();
         let f = if lin_out && lin_in || len <= 1e-12 {
@@ -617,6 +647,7 @@ pub fn set_key(keys: &mut Vec<Keyframe>, key: Keyframe) -> usize {
             k.spatial_continuous = old.spatial_continuous;
             k.roving = old.roving;
             k.label = old.label;
+            k.muted = old.muted;
             keys[i] = k;
             i
         }

crates/keyframe/src/tests.rs

@@ -395,3 +395,59 @@ proptest::proptest! {
         proptest::prop_assert!((-1e-9..=10.0 + 1e-9).contains(&v));
     }
 }
+
+#[test]
+fn muted_keys_are_skipped_by_evaluation() {
+    let mut keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), Keyframe::new(s(1.0), Value::Scalar(100.0)), Keyframe::new(s(2.0), Value::Scalar(300.0))];
+    let at = |keys: &[Keyframe], t: f64| evaluate(keys, s(t), false).unwrap().as_f64();
+    assert!((at(&keys, 0.5) - 50.0).abs() < 1e-9);
+    assert!((at(&keys, 1.5) - 200.0).abs() < 1e-9);
+    keys[1].muted = true;
+    // The 0 → 300 segment now spans 0 → 2 s.
+    assert!((at(&keys, 0.5) - 75.0).abs() < 1e-9);
+    assert!((at(&keys, 1.0) - 150.0).abs() < 1e-9);
+    assert!((at(&keys, 1.5) - 225.0).abs() < 1e-9);
+    for k in &mut keys {
+        k.muted = true;
+    }
+    assert!(evaluate(&keys, s(0.5), false).is_none());
+}
+
+#[test]
+fn muted_key_automation_uses_the_active_neighbours() {
+    let mut keys = vec![
+        Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])),
+        Keyframe::new(s(1.0), Value::Vec2([50.0, 100.0])),
+        Keyframe::new(s(2.0), Value::Vec2([100.0, 0.0])),
+    ];
+    for k in &mut keys {
+        k.auto_bezier = true;
+        k.in_interp = Interp::Bezier;
+        k.out_interp = Interp::Bezier;
+    }
+    let all = keys.clone();
+    let mut active = keys.clone();
+    active.remove(1);
+    keys[1].muted = true;
+    for t in [0.0, 0.25, 0.5, 1.0, 1.5, 1.75, 2.0] {
+        assert_eq!(evaluate(&keys, s(t), true), evaluate(&active, s(t), true), "{t}");
+    }
+    // The muted auto-Bezier key no longer bulges the motion path.
+    assert_ne!(evaluate(&keys, s(0.5), true), evaluate(&all, s(0.5), true));
+}
+
+#[test]
+fn mute_round_trips_and_survives_value_replacement() {
+    let mut k = Keyframe::new(s(0.0), Value::Scalar(1.0));
+    let json = serde_json::to_value(&k).unwrap();
+    assert!(json.get("muted").is_none(), "false is the default and is skipped");
+    k.muted = true;
+    let json = serde_json::to_value(&k).unwrap();
+    assert_eq!(json["muted"], serde_json::json!(true));
+    let back: Keyframe = serde_json::from_value(json).unwrap();
+    assert!(back.muted);
+    let mut keys = vec![k];
+    set_key(&mut keys, Keyframe::new(s(0.0), Value::Scalar(2.0)));
+    assert!(keys[0].muted);
+    assert_eq!(keys[0].value, Value::Scalar(2.0));
+}

crates/lottie/src/anim.rs

@@ -73,9 +73,22 @@ fn is_spatial(p: &Property) -> bool {
 }
 
 /// Export a property as a Lottie animatable property (`{a, k}` plus `x` for expressions).
-/// `label` names the property in warnings.
+/// `label` names the property in warnings. Muted keys are omitted: Lottie has no mute state, and
+/// the remaining keys carry the animation the renderer shows.
 pub(crate) fn export_prop(ex: &mut Ex, p: &Property, conv: &dyn Fn(&Value) -> Json, label: &str) -> Json {
-    let mut out = if p.keys.is_empty() { json!({"a": 0, "k": conv(&p.value)}) } else { json!({"a": 1, "k": export_keys(ex, p, conv)}) };
+    let muted = p.keys.iter().any(|k| k.muted);
+    if muted {
+        ex.warn(format!("{label}: muted keyframes are not exported"));
+    }
+    let active: Vec<Keyframe>;
+    let keys: &[Keyframe] = if muted {
+        active = p.keys.iter().filter(|k| !k.muted).cloned().collect();
+        &active
+    } else {
+        &p.keys
+    };
+    let mut out =
+        if keys.is_empty() { json!({"a": 0, "k": conv(&p.value)}) } else { json!({"a": 1, "k": export_keys(ex, keys, is_spatial(p), p.hold_only, conv)}) };
     if let Some(e) = p.expr.as_ref().filter(|e| e.enabled && !e.text.trim().is_empty()) {
         if ex.include_expressions {
             out["x"] = json!(e.text);
@@ -86,20 +99,18 @@ pub(crate) fn export_prop(ex: &mut Ex, p: &Property, conv: &dyn Fn(&Value) -> Js
     out
 }
 
-fn export_keys(ex: &Ex, p: &Property, conv: &dyn Fn(&Value) -> Json) -> Vec<Json> {
-    let keys = &p.keys;
-    let spatial = is_spatial(p);
+fn export_keys(ex: &Ex, keys: &[Keyframe], spatial: bool, hold_only: bool, conv: &dyn Fn(&Value) -> Json) -> Vec<Json> {
     let mut out = Vec::with_capacity(keys.len());
     for (i, k) in keys.iter().enumerate() {
         let mut o = json!({"t": r6(ex.tb.frame(k.time)), "s": wrap(conv(&k.value))});
         if i + 1 == keys.len() {
-            if k.out_interp == Interp::Hold || p.hold_only {
+            if k.out_interp == Interp::Hold || hold_only {
                 o["h"] = json!(1);
             }
             out.push(o);
             continue;
         }
-        if k.out_interp == Interp::Hold || p.hold_only || !k.value.interpolates() {
+        if k.out_interp == Interp::Hold || hold_only || !k.value.interpolates() {
             o["h"] = json!(1);
             out.push(o);
             continue;

crates/lottie/src/tests.rs

@@ -878,3 +878,21 @@ fn external_images_are_local_or_skipped() {
     assert_eq!(std::path::Path::new(&paths[0]), base.join("images").join("a.png"));
     assert_eq!(r.warnings.iter().filter(|w| w.contains("is not imported")).count(), assets.len() - 1, "{:?}", r.warnings);
 }
+
+#[test]
+fn muted_keys_are_omitted_from_the_export() {
+    let (mut p, cid) = setup();
+    let mut l = solid_layer(&mut p, cid, [0.0, 1.0, 0.0], 20, 20);
+    let mut b = Keyframe::new(s(1.0), Value::Scalar(100.0));
+    b.muted = true;
+    l.props.prop_mut("transform/opacity").unwrap().keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), b, Keyframe::new(s(2.0), Value::Scalar(300.0))];
+    push(&mut p, cid, l);
+    let (q, nc, warnings, json) = roundtrip(&p, cid, &ExportOptions::default());
+    assert!(warnings.iter().any(|w| w.contains("muted keyframes")), "{warnings:?}");
+    // Lottie has no mute state: the two active keys carry the 0 → 300 animation.
+    assert_eq!(json["layers"][0]["ks"]["o"]["k"].as_array().unwrap().len(), 2);
+    assert_eq!(json["layers"][0]["ks"]["o"]["k"][1]["s"], json!([300.0]));
+    let opacity_at = |p: &Project, cid: ItemId, t: f64| p.comp(cid).unwrap().layers[0].props.prop("transform/opacity").unwrap().value_at(s(t)).as_f64();
+    assert!((opacity_at(&p, cid, 1.0) - 150.0).abs() < 1e-6);
+    assert!((opacity_at(&q, nc, 1.0) - 150.0).abs() < 1e-6);
+}

crates/media/src/probe.rs

@@ -23,6 +23,7 @@ pub fn probe(path: impl AsRef<Path>) -> Result<Footage> {
         let turn = header.as_deref().map_or(Orientation::NoTransforms, video_turn);
         turn_footage(&mut f, turn);
         correct_rate(&mut f, header.as_deref().and_then(video_rate));
+        trim_to_edits(&mut f, header.as_deref().and_then(video_shown));
         return Ok(f);
     }
     let bytes = crate::read_regular_file(path).map_err(|e| MediaError::Io(format!("{}: {e}", path.display())))?;
@@ -107,6 +108,7 @@ pub fn probe_bytes(path: &str, bytes: Arc<[u8]>) -> Result<Footage> {
     let name = Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| path.to_string());
     let turn = video_turn(&bytes);
     let rate = video_rate(&bytes);
+    let shown = video_shown(&bytes);
     // A WAV's cue points and XMP markers become the footage's markers.
     let markers = crate::wav_markers::read(&bytes);
     let src = filmcraft_codecs::open_bytes(&name, bytes)?;
@@ -114,9 +116,37 @@ pub fn probe_bytes(path: &str, bytes: Arc<[u8]>) -> Result<Footage> {
     f.markers = markers;
     turn_footage(&mut f, turn);
     correct_rate(&mut f, rate);
+    trim_to_edits(&mut f, shown);
     Ok(f)
 }
 
+/// A movie lasts as long as its video edit list shows (#2592): the reader reports the media
+/// duration (`mdhd`), which for H.264 with B-frames runs past the last shown frame by the
+/// encoder delay the edit list trims (75 frames at 25 fps read as 3.04 s). Never lengthens.
+fn trim_to_edits(f: &mut Footage, shown: Option<Tick>) {
+    if f.kind == FootageKind::Video
+        && let Some(shown) = shown.filter(|s| *s > Tick::ZERO && *s < f.duration)
+    {
+        f.duration = shown;
+    }
+}
+
+/// How long the video track's edit list shows its media (`elst` segments, movie timescale):
+/// `None` without edits, or with an empty edit (a delayed start keeps the reader's duration).
+fn video_shown(bytes: &[u8]) -> Option<Tick> {
+    let file = filmcraft_isobmff::open(bytes).ok()?;
+    let t = file.tracks.iter().find(|t| t.kind == filmcraft_isobmff::TrackKind::Video && !t.samples.is_empty())?;
+    edits_shown(&t.edits, file.timescale)
+}
+
+fn edits_shown(edits: &[filmcraft_isobmff::Edit], timescale: u32) -> Option<Tick> {
+    if edits.is_empty() || timescale == 0 || edits.iter().any(|e| e.media_time < 0) {
+        return None;
+    }
+    let units = edits.iter().try_fold(0u64, |acc, e| acc.checked_add(e.segment_duration))?;
+    Some(Tick::from_units(i64::try_from(units).ok()?, i64::from(timescale)))
+}
+
 /// A movie's frame rate as its frame durations average to ([`video_rate`]), where the reader's
 /// own estimate misreads it.
 fn correct_rate(f: &mut Footage, rate: Option<FrameRate>) {
@@ -329,6 +359,24 @@ fn averaged_rate(timescale: u32, durations: impl Iterator<Item = u32>) -> Option
 mod tests {
     use super::*;
 
+    /// #2592: an encoder-delayed H.264 track's edit list shows 75 frames at 25 fps (3 s at a
+    /// 1000 timescale), though its media runs a frame longer; empty edits and no edits leave it.
+    #[test]
+    fn the_edit_list_trims_a_movie_to_the_frames_it_shows() {
+        let edit = |segment_duration, media_time| filmcraft_isobmff::Edit { segment_duration, media_time, media_rate: 0x0001_0000 };
+        let shown = edits_shown(&[edit(3000, 1024)], 1000);
+        assert_eq!(shown, Some(Tick::from_units(3, 1)));
+        let mut f = Footage { kind: FootageKind::Video, duration: Tick::from_units(76, 25), ..Footage::default() };
+        trim_to_edits(&mut f, shown);
+        assert_eq!(f.duration, Tick::from_units(75, 25));
+        // Never longer than the reader's duration, and only for video.
+        trim_to_edits(&mut f, Some(Tick::from_units(4, 1)));
+        assert_eq!(f.duration, Tick::from_units(75, 25));
+        assert_eq!(edits_shown(&[edit(1000, -1), edit(3000, 0)], 1000), None);
+        assert_eq!(edits_shown(&[], 1000), None);
+        assert_eq!(edits_shown(&[edit(3000, 0)], 0), None);
+    }
+
     /// Durations (in 1/`timescale` s) of `n` frames at `rate` whose times are rounded to the timescale.
     fn rounded(rate: FrameRate, timescale: i64, n: i64) -> Vec<u32> {
         let at = |k: i64| (2 * k * timescale * rate.den + rate.num) / (2 * rate.num);

crates/project/src/build.rs

@@ -596,6 +596,22 @@ pub fn shape_simple_op(ids: &mut Ids, kind: &str) -> Option<PropGroup> {
             .with(ids.prop("phase", "Temporal Phase", Value::Scalar(0.0)).with_ui(ParamUi::Angle))
             .with(wiggle_spatial_phase(ids))
             .with(ids.prop("seed", "Random Seed", Value::Scalar(0.0))),
+        "wiggler" | "wiggleTransform" => {
+            // The Transform group holds how far each transformation wiggles.
+            let tr = ids
+                .group("transform", "Transform")
+                .with(ids.prop("anchor", "Anchor Point", Value::Vec2([0.0, 0.0])).with_ui(ParamUi::Point))
+                .with(ids.prop("position", "Position", Value::Vec2([0.0, 0.0])).with_ui(ParamUi::Point))
+                .with(ids.prop("scale", "Scale", Value::Vec2([0.0, 0.0])).with_ui(ParamUi::Percent))
+                .with(ids.prop("rotation", "Rotation", Value::Scalar(0.0)).with_ui(ParamUi::Angle));
+            indexed(ids.group("wiggler", "Wiggle Transform 1"))
+                .with(ids.prop("speed", "Wiggles/Second", Value::Scalar(2.0)))
+                .with(ids.prop("correlation", "Correlation", Value::Scalar(50.0)).with_ui(ParamUi::Percent))
+                .with(ids.prop("phase", "Temporal Phase", Value::Scalar(0.0)).with_ui(ParamUi::Angle))
+                .with(ids.prop("spatialPhase", "Spatial Phase", Value::Scalar(0.0)).with_ui(ParamUi::Angle))
+                .with(ids.prop("seed", "Random Seed", Value::Scalar(0.0)))
+                .with(tr)
+        }
         "merge" => indexed(ids.group("merge", "Merge Paths 1")).with(ids.prop("mode", "Mode", Value::Enum(0)).with_ui(popup(&[
             "Merge",
             "Add",
@@ -681,10 +697,16 @@ pub fn light_options(ids: &mut Ids, kind: LightKind) -> PropGroup {
     }
     if kind == LightKind::Environment {
         // The environment image: a layer (footage, comp…) mapped as an equirectangular panorama;
-        // none = the comp's Environment Layer.
+        // none = the comp's Environment Layer, or a flat default environment of the light's
+        // colour × intensity when there is none. No Falloff: an environment light shines from
+        // every direction at once. Environment lights cast shadows too (After Effects' Light
+        // Settings shows Cast Shadows for them; not for Ambient) (#2436).
         return g
             .with(ids.prop("source", "Source", Value::Layer(None)).with_ui(ParamUi::Layer))
-            .with(ids.prop("rotation", "Environment Rotation", Value::Scalar(0.0)).with_ui(ParamUi::Angle));
+            .with(ids.prop("rotation", "Environment Rotation", Value::Scalar(0.0)).with_ui(ParamUi::Angle))
+            .with(ids.prop("castsShadows", "Casts Shadows", Value::Bool(false)).with_ui(ParamUi::Checkbox))
+            .with(ids.prop("shadowDarkness", "Shadow Darkness", Value::Scalar(100.0)).with_ui(ParamUi::Percent))
+            .with(ids.prop("shadowDiffusion", "Shadow Diffusion", Value::Scalar(0.0)).with_ui(ParamUi::Pixels));
     }
     if kind != LightKind::Ambient {
         g = g

crates/project/src/comp.rs

@@ -87,8 +87,8 @@ pub struct Comp {
     pub display_start: Tick,
     pub background: [f32; 3],
     pub work_area: (Tick, Tick),
-    /// Layer #1 first (top of the stack).
-    pub layers: Vec<Layer>,
+    /// Layer #1 first (top of the stack). Each layer is shared between undo states until edited.
+    pub layers: super::Layers,
     #[serde(default)]
     pub markers: Vec<Marker>,
     pub shutter_angle: f64,
@@ -188,7 +188,7 @@ impl Comp {
             display_start: Tick::ZERO,
             background: [0.0, 0.0, 0.0],
             work_area: (Tick::ZERO, duration),
-            layers: vec![],
+            layers: super::Layers::new(),
             markers: vec![],
             shutter_angle: 180.0,
             shutter_phase: -90.0,
@@ -239,7 +239,7 @@ impl Comp {
     }
 
     pub fn layer_mut(&mut self, id: LayerId) -> Option<&mut Layer> {
-        self.layers.iter_mut().find(|l| l.id == id)
+        self.layers.find_mut(|l| l.id == id)
     }
 
     /// 1-based layer number (#) of a layer.

crates/project/src/footage.rs

@@ -57,6 +57,142 @@ pub enum AlphaMode {
     Ignore,
 }
 
+/// Interpret Footage ▸ Cineon Settings ▸ Units: how the Converted Black and White Points are
+/// shown and entered.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum CineonUnits {
+    /// 10-bit code values (0–1023).
+    #[default]
+    TenBit,
+    /// 8-bit values (0–255).
+    EightBit,
+    /// Floating point (0–1).
+    Float,
+}
+
+impl CineonUnits {
+    pub const ALL: [CineonUnits; 3] = [CineonUnits::TenBit, CineonUnits::EightBit, CineonUnits::Float];
+
+    /// The id commands use: `10bit`, `8bit` or `float`.
+    pub fn id(self) -> &'static str {
+        match self {
+            CineonUnits::TenBit => "10bit",
+            CineonUnits::EightBit => "8bit",
+            CineonUnits::Float => "float",
+        }
+    }
+
+    pub fn label(self) -> &'static str {
+        match self {
+            CineonUnits::TenBit => "10-bit",
+            CineonUnits::EightBit => "8-bit",
+            CineonUnits::Float => "Float",
+        }
+    }
+
+    pub fn parse(s: &str) -> Option<CineonUnits> {
+        match s.to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
+            "10bit" | "10" => Some(CineonUnits::TenBit),
+            "8bit" | "8" => Some(CineonUnits::EightBit),
+            "float" | "32bit" => Some(CineonUnits::Float),
+            _ => None,
+        }
+    }
+
+    /// A 10-bit value (0–1023) in these units.
+    pub fn from_ten_bit(self, v: f64) -> f64 {
+        match self {
+            CineonUnits::TenBit => v,
+            CineonUnits::EightBit => v * 255.0 / 1023.0,
+            CineonUnits::Float => v / 1023.0,
+        }
+    }
+
+    /// A value in these units as a 10-bit value (0–1023).
+    pub fn to_ten_bit(self, v: f64) -> f64 {
+        match self {
+            CineonUnits::TenBit => v,
+            CineonUnits::EightBit => v * 1023.0 / 255.0,
+            CineonUnits::Float => v * 1023.0,
+        }
+    }
+}
+
+/// Interpret Footage ▸ Cineon Settings of DPX and Cineon footage: how the file's logarithmic
+/// (printing density) code values become the footage's pixels. Code values are counted in 10-bit
+/// units whatever the file's bit depth.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct CineonSettings {
+    /// Logarithmic Conversion: convert the code values from log to the Current Gamma. When it
+    /// is off, the code values are shown as stored.
+    pub log_conversion: bool,
+    /// Converted Black Point: the level the 10 Bit Black Point becomes (10-bit units).
+    pub converted_black: f32,
+    /// Converted White Point: the level the 10 Bit White Point becomes (10-bit units).
+    pub converted_white: f32,
+    /// 10 Bit Black Point: the code value of minimum density.
+    pub black: f32,
+    /// 10 Bit White Point: the code value of maximum density.
+    pub white: f32,
+    /// Current Gamma: the gamma the converted values are encoded with (1: linear light).
+    pub gamma: f32,
+    /// Highlight Rolloff (0–100): values near and above the white point ramp off gradually
+    /// instead of clipping; 0 keeps over-range values.
+    pub rolloff: f32,
+    /// Units of the Converted Black and White Points.
+    pub units: CineonUnits,
+}
+
+impl Default for CineonSettings {
+    fn default() -> Self {
+        CineonSettings {
+            log_conversion: false,
+            converted_black: 0.0,
+            converted_white: 1023.0,
+            black: 95.0,
+            white: 685.0,
+            gamma: 1.7,
+            rolloff: 20.0,
+            units: CineonUnits::TenBit,
+        }
+    }
+}
+
+impl CineonSettings {
+    /// The highest 10-bit value.
+    pub const MAX: f32 = 1023.0;
+
+    /// A code value (0–1 of the 10-bit range) converted from log to the Current Gamma and the
+    /// converted black and white levels (0–1; above 1 for over-range highlights).
+    pub fn convert(&self, v: f32) -> f32 {
+        let lin = cineon_log_to_lin(v, self.black, self.white, 1.0, self.gamma, self.rolloff);
+        let out = (self.converted_black + (self.converted_white - self.converted_black) * lin) / Self::MAX;
+        if out.is_finite() { out } else { 0.0 }
+    }
+}
+
+/// Cineon log to linear, shared by Interpret Footage ▸ Cineon Settings and the Cineon Converter
+/// effect. `v` is a code value as 0–1 of the 10-bit range; `black` and `white` are the 10 Bit
+/// Black and White Points. The result is 0 at the black point and 1 at the white point, raised to
+/// `scale / gamma`, with values above `1 - rolloff / 100` ramped off toward 1 (Highlight Rolloff
+/// 0–100; 0 keeps over-range values). A Gamma below 0.01 is raised to 0.01. Cineon Settings passes
+/// a `scale` of 1 (Gamma 1 gives linear light) and the Cineon Converter passes 1.7 (its default
+/// Gamma 1.7 gives linear light).
+pub fn cineon_log_to_lin(v: f32, black: f32, white: f32, scale: f32, gamma: f32, rolloff: f32) -> f32 {
+    // Kodak printing density: 0.002 density per code value, negative gamma 0.6.
+    let exposure = |code: f32| 10f32.powf((code - white) * 0.002 / 0.6);
+    let offset = exposure(black);
+    let mut lin = ((exposure(v * CineonSettings::MAX) - offset) / (1.0 - offset).max(1e-6)).max(0.0);
+    lin = lin.powf(scale / gamma.max(0.01));
+    let knee = 1.0 - (rolloff / 100.0).clamp(0.0, 0.99);
+    if knee < 1.0 && lin > knee {
+        let w = 1.0 - knee;
+        lin = knee + w * (1.0 - (-(lin - knee) / w).exp());
+    }
+    lin
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Footage {
     pub path: String,
@@ -103,6 +239,9 @@ pub struct Footage {
     /// colour profile, Interpret As Linear Light and the working space don't apply.
     #[serde(default, skip_serializing_if = "std::ops::Not::not")]
     pub preserve_rgb: bool,
+    /// Interpret Footage ▸ Cineon Settings (DPX and Cineon files only; [`Footage::cineon_applies`]).
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub cineon: CineonSettings,
     /// Data footage ([`FootageKind::Data`]): the file's text (JSON, CSV or TSV), kept in the
     /// project so expressions read it everywhere (and on the web).
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -154,6 +293,7 @@ impl Default for Footage {
             invert_alpha: false,
             linear_light: false,
             preserve_rgb: false,
+            cineon: CineonSettings::default(),
             data: None,
             layer: None,
             page: 0,
@@ -165,6 +305,17 @@ impl Default for Footage {
 }
 
 impl Footage {
+    /// The file is DPX or Cineon (the formats Interpret Footage ▸ Cineon Settings applies to).
+    pub fn is_cineon_file(&self) -> bool {
+        let ext = std::path::Path::new(&self.path).extension().and_then(|e| e.to_str()).unwrap_or("").to_ascii_lowercase();
+        matches!(ext.as_str(), "dpx" | "cin")
+    }
+
+    /// Cineon Settings ▸ Logarithmic Conversion applies: it is on and the file is DPX or Cineon.
+    pub fn cineon_applies(&self) -> bool {
+        self.cineon.log_conversion && self.is_cineon_file()
+    }
+
     /// Interpret As Linear Light applies (Preserve RGB passes the file's values through).
     pub fn linear_light_applies(&self) -> bool {
         self.linear_light && !self.preserve_rgb

crates/project/src/layers.rs

@@ -0,0 +1,209 @@
+//! A comp's layer stack with structural sharing.
+//!
+//! Every undoable edit keeps the previous project for undo, so the comp it touches is shared and
+//! `Arc::make_mut` copies it. With the layers stored inline that copy is the whole stack, every
+//! layer and every keyframe, so an edit costs time in proportion to the comp's size and a script
+//! that sets many keys in a big comp goes quadratic. Here each layer sits behind its own `Arc`:
+//! copying the stack copies pointers, and only the layer an edit actually changes is copied.
+//!
+//! The API mirrors the `Vec<Layer>` it replaces. Serialized form is identical (a list of layers).
+
+use std::ops::{Index, IndexMut};
+use std::sync::Arc;
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use super::layer::Layer;
+
+/// Layer #1 first (top of the stack).
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Layers(Vec<Arc<Layer>>);
+
+impl Layers {
+    pub const fn new() -> Self {
+        Self(Vec::new())
+    }
+    pub fn with_capacity(n: usize) -> Self {
+        Self(Vec::with_capacity(n))
+    }
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+    pub fn iter(&self) -> impl DoubleEndedIterator<Item = &Layer> + ExactSizeIterator + Clone {
+        self.0.iter().map(|l| &**l)
+    }
+    /// Mutable access to every layer: each one that is still shared with an undo state is copied,
+    /// so prefer [`Layers::get_mut`] (or `iter` to find, then `get_mut`) when only some change.
+    pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Layer> + ExactSizeIterator {
+        self.0.iter_mut().map(Arc::make_mut)
+    }
+    /// Mutable access to just the layers `keep` accepts. `keep` reads each layer without copying
+    /// it; only the matching ones are copied (if shared). Use this, not `iter_mut().filter(..)`.
+    pub fn iter_mut_where<'a>(&'a mut self, mut keep: impl FnMut(&Layer) -> bool + 'a) -> impl Iterator<Item = &'a mut Layer> + 'a {
+        self.0.iter_mut().filter(move |l| keep(l)).map(Arc::make_mut)
+    }
+    /// The first layer `pred` accepts, copied only if it is that one. Use this, not `iter_mut().find(..)`.
+    pub fn find_mut(&mut self, mut pred: impl FnMut(&Layer) -> bool) -> Option<&mut Layer> {
+        self.0.iter_mut().find(|l| pred(l)).map(Arc::make_mut)
+    }
+    pub fn get(&self, i: usize) -> Option<&Layer> {
+        self.0.get(i).map(|l| &**l)
+    }
+    pub fn get_mut(&mut self, i: usize) -> Option<&mut Layer> {
+        self.0.get_mut(i).map(Arc::make_mut)
+    }
+    pub fn first(&self) -> Option<&Layer> {
+        self.get(0)
+    }
+    pub fn last(&self) -> Option<&Layer> {
+        self.0.last().map(|l| &**l)
+    }
+    pub fn first_mut(&mut self) -> Option<&mut Layer> {
+        self.get_mut(0)
+    }
+    pub fn last_mut(&mut self) -> Option<&mut Layer> {
+        self.0.last_mut().map(Arc::make_mut)
+    }
+    pub fn push(&mut self, l: Layer) {
+        self.0.push(Arc::new(l));
+    }
+    pub fn insert(&mut self, i: usize, l: Layer) {
+        self.0.insert(i, Arc::new(l));
+    }
+    pub fn remove(&mut self, i: usize) -> Layer {
+        Arc::unwrap_or_clone(self.0.remove(i))
+    }
+    pub fn pop(&mut self) -> Option<Layer> {
+        self.0.pop().map(Arc::unwrap_or_clone)
+    }
+    pub fn retain(&mut self, mut f: impl FnMut(&Layer) -> bool) {
+        self.0.retain(|l| f(l));
+    }
+    pub fn swap(&mut self, a: usize, b: usize) {
+        self.0.swap(a, b);
+    }
+    pub fn truncate(&mut self, n: usize) {
+        self.0.truncate(n);
+    }
+    pub fn clear(&mut self) {
+        self.0.clear();
+    }
+    pub fn reverse(&mut self) {
+        self.0.reverse();
+    }
+    pub fn sort_by_key<K: Ord>(&mut self, mut f: impl FnMut(&Layer) -> K) {
+        self.0.sort_by_key(|l| f(l));
+    }
+    pub fn sort_by(&mut self, mut f: impl FnMut(&Layer, &Layer) -> std::cmp::Ordering) {
+        self.0.sort_by(|a, b| f(a, b));
+    }
+    pub fn rotate_left(&mut self, n: usize) {
+        self.0.rotate_left(n);
+    }
+    pub fn rotate_right(&mut self, n: usize) {
+        self.0.rotate_right(n);
+    }
+    /// `layers[range].rotate_left(n)` (a slice of `Arc`s can't be handed out as a `&mut [Layer]`).
+    pub fn rotate_range_left(&mut self, r: impl std::slice::SliceIndex<[Arc<Layer>], Output = [Arc<Layer>]>, n: usize) {
+        if let Some(s) = self.0.get_mut(r) {
+            s.rotate_left(n);
+        }
+    }
+    pub fn rotate_range_right(&mut self, r: impl std::slice::SliceIndex<[Arc<Layer>], Output = [Arc<Layer>]>, n: usize) {
+        if let Some(s) = self.0.get_mut(r) {
+            s.rotate_right(n);
+        }
+    }
+    pub fn split_off(&mut self, at: usize) -> Layers {
+        Layers(self.0.split_off(at))
+    }
+    pub fn append(&mut self, other: &mut Layers) {
+        self.0.append(&mut other.0);
+    }
+    /// Remove a range of layers and return them (owned).
+    pub fn drain(&mut self, r: impl std::ops::RangeBounds<usize>) -> std::vec::IntoIter<Layer> {
+        self.0.drain(r).map(Arc::unwrap_or_clone).collect::<Vec<_>>().into_iter()
+    }
+    /// Whether `self` and `other` hold the very same (unchanged) layer at `i`: a cheap "did this
+    /// layer change" test between two project states.
+    pub fn same_at(&self, other: &Layers, i: usize) -> bool {
+        matches!((self.0.get(i), other.0.get(i)), (Some(a), Some(b)) if Arc::ptr_eq(a, b))
+    }
+    /// The shared layers themselves, for parallel iteration (`rayon` over `&[Arc<Layer>]`).
+    pub fn as_arcs(&self) -> &[Arc<Layer>] {
+        &self.0
+    }
+    pub fn to_vec(&self) -> Vec<Layer> {
+        self.iter().cloned().collect()
+    }
+}
+
+impl Index<usize> for Layers {
+    type Output = Layer;
+    fn index(&self, i: usize) -> &Layer {
+        &self.0[i]
+    }
+}
+
+impl IndexMut<usize> for Layers {
+    fn index_mut(&mut self, i: usize) -> &mut Layer {
+        Arc::make_mut(&mut self.0[i])
+    }
+}
+
+impl From<Vec<Layer>> for Layers {
+    fn from(v: Vec<Layer>) -> Self {
+        Self(v.into_iter().map(Arc::new).collect())
+    }
+}
+
+impl FromIterator<Layer> for Layers {
+    fn from_iter<I: IntoIterator<Item = Layer>>(it: I) -> Self {
+        Self(it.into_iter().map(Arc::new).collect())
+    }
+}
+
+impl Extend<Layer> for Layers {
+    fn extend<I: IntoIterator<Item = Layer>>(&mut self, it: I) {
+        self.0.extend(it.into_iter().map(Arc::new));
+    }
+}
+
+impl IntoIterator for Layers {
+    type Item = Layer;
+    type IntoIter = std::iter::Map<std::vec::IntoIter<Arc<Layer>>, fn(Arc<Layer>) -> Layer>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter().map(Arc::unwrap_or_clone as fn(Arc<Layer>) -> Layer)
+    }
+}
+
+impl<'a> IntoIterator for &'a Layers {
+    type Item = &'a Layer;
+    type IntoIter = std::iter::Map<std::slice::Iter<'a, Arc<Layer>>, fn(&'a Arc<Layer>) -> &'a Layer>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter().map(|l| &**l)
+    }
+}
+
+impl<'a> IntoIterator for &'a mut Layers {
+    type Item = &'a mut Layer;
+    type IntoIter = std::iter::Map<std::slice::IterMut<'a, Arc<Layer>>, fn(&'a mut Arc<Layer>) -> &'a mut Layer>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter_mut().map(Arc::make_mut)
+    }
+}
+
+impl Serialize for Layers {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        s.collect_seq(self.iter())
+    }
+}
+
+impl<'de> Deserialize<'de> for Layers {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        Vec::<Layer>::deserialize(d).map(Layers::from)
+    }
+}

crates/project/src/lib.rs

@@ -1,8 +1,8 @@
 //! The EffectCraft document model.
 //!
 //! `Project` → items (folders, compositions, footage, solids) → `Comp` → `Layer` → property tree
-//! ([`props`]). Compositions sit behind `Arc` so undo snapshots share everything that did not
-//! change.
+//! ([`props`]). Compositions, and each layer within them ([`Layers`]), sit behind `Arc` so undo
+//! snapshots share everything that did not change.
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
@@ -33,12 +33,14 @@ mod comp;
 mod footage;
 mod item;
 mod layer;
+mod layers;
 mod settings;
 
 pub use comp::{Comp, Guide, Renderer, Resolution};
-pub use footage::{AlphaMode, FieldOrder, Footage, FootageKind, Proxy, Solid, SourceLayer, VIDEO_EXTENSIONS};
+pub use footage::{AlphaMode, CineonSettings, CineonUnits, FieldOrder, Footage, FootageKind, Proxy, Solid, SourceLayer, VIDEO_EXTENSIONS, cineon_log_to_lin};
 pub use item::{Item, ItemId, ItemKind, LayerId};
 pub use layer::{AutoOrient, FrameBlend, Layer, LayerSource, LightKind, MatteKind, PrimitiveKind, Quality, Sampling, Switches, TrackMatte};
+pub use layers::Layers;
 pub use settings::{
     APP_VERSION, BitDepth, ColorEngine, CuePoint, HdrMode, Marker, ProjectError, ProjectSettings, SCHEMA_EFFECT_SPACE, SCHEMA_VERSION, SavedView,
     TimeDisplayStyle, is_newer_version, saved_by, saved_view,

crates/project/src/styles.rs

@@ -470,7 +470,7 @@ mod tests {
         let mut ids = Ids(&mut p.next_id);
         add_style(&mut a, &mut ids, "dropShadow", &gl, true);
         add_style(&mut b, &mut ids, "bevelEmboss", &gl, true);
-        comp.layers = vec![a, b];
+        comp.layers = vec![a, b].into();
         comp.layers[1].props.sub_mut(GROUP).unwrap().sub_mut(BLENDING).unwrap().get_mut("globalLightAngle").unwrap().value = Value::Scalar(45.0);
         assert!(needs_sync(&comp));
         sync_comp(&mut comp);

crates/project/src/tests.rs

@@ -291,6 +291,49 @@ fn comp_contains_ends_on_cycles_long_chains_and_shared_precomps() {
     assert!(!p.comp_contains(c[n - 1], c[0]));
 }
 
+/// Interpret Footage ▸ Cineon Settings: the 10 Bit Black and White Points become the converted
+/// points, Current Gamma 1 gives linear light, Highlight Rolloff 0 keeps over-range values and
+/// a higher one ramps them off; the settings apply only to DPX and Cineon files, and projects
+/// saved without them read the defaults.
+#[test]
+fn cineon_settings_convert_log_code_values() {
+    use crate::{CineonSettings, CineonUnits, Footage};
+    let code = |v: f32| v / 1023.0;
+    let c = CineonSettings { log_conversion: true, rolloff: 0.0, ..Default::default() };
+    assert!(c.convert(code(95.0)).abs() < 1e-6, "black point");
+    assert!((c.convert(code(685.0)) - 1.0).abs() < 1e-5, "white point");
+    // Code 400: (10^(-0.95) - 10^(-1.9667)) / (1 - 10^(-1.9667)) = 0.10251 linear, ^(1/1.7).
+    assert!((c.convert(code(400.0)) - 0.26190).abs() < 1e-4, "{}", c.convert(code(400.0)));
+    let linear = CineonSettings { gamma: 1.0, ..c };
+    assert!((linear.convert(code(400.0)) - 0.10251).abs() < 1e-4, "{}", linear.convert(code(400.0)));
+    assert!(c.convert(code(1023.0)) > 1.5, "over range kept: {}", c.convert(code(1023.0)));
+    // The default rolloff (20) ramps the white point and above off, up to 1.
+    let rolled = CineonSettings { rolloff: 20.0, ..c };
+    let (w, mid, top) = (rolled.convert(code(685.0)), rolled.convert(code(720.0)), rolled.convert(code(1023.0)));
+    assert!(w > 0.8 && w < mid && mid < top && top <= 1.0, "{w} {mid} {top}");
+    let points = CineonSettings { converted_black: 64.0, converted_white: 940.0, ..c };
+    assert!((points.convert(code(95.0)) - 64.0 / 1023.0).abs() < 1e-5);
+    assert!((points.convert(code(685.0)) - 940.0 / 1023.0).abs() < 1e-5);
+    // Units.
+    assert!((CineonUnits::EightBit.from_ten_bit(1023.0) - 255.0).abs() < 1e-9);
+    assert!((CineonUnits::Float.to_ten_bit(0.5) - 511.5).abs() < 1e-9);
+    assert_eq!(CineonUnits::parse("8-bit"), Some(CineonUnits::EightBit));
+    assert!(CineonUnits::ALL.iter().all(|u| CineonUnits::parse(u.id()) == Some(*u)));
+    // DPX and Cineon files only, and only with Logarithmic Conversion on.
+    let on = CineonSettings { log_conversion: true, ..Default::default() };
+    let dpx = Footage { path: "/m/plate.0001.DPX".into(), cineon: on, ..Default::default() };
+    assert!(dpx.cineon_applies());
+    assert!(Footage { path: "/m/scan.cin".into(), cineon: on, ..Default::default() }.cineon_applies());
+    assert!(!Footage { path: "/m/still.png".into(), cineon: on, ..Default::default() }.cineon_applies());
+    assert!(!Footage { path: "/m/plate.dpx".into(), ..Default::default() }.cineon_applies());
+    // Saved only when changed; read back, and absent in older projects.
+    let plain = serde_json::to_value(Footage { path: "/m/a.dpx".into(), ..Default::default() }).unwrap();
+    assert!(plain.get("cineon").is_none(), "{plain}");
+    let saved = serde_json::to_string(&dpx).unwrap();
+    assert_eq!(serde_json::from_str::<Footage>(&saved).unwrap().cineon, on);
+    assert_eq!(serde_json::from_value::<Footage>(plain).unwrap().cineon, CineonSettings::default());
+}
+
 /// A Wiggle Paths 100 000 groups deep gets Spatial Phase on a 2 MiB stack.
 #[test]
 fn upgrading_deeply_nested_shape_groups_fits_a_small_stack() {

crates/render/src/accel.rs

@@ -131,6 +131,14 @@ pub trait FxTarget {
             buf
         });
     }
+    /// Give the buffer the pixel-grid phase the layer rectangle's cover would
+    /// ([`effectcraft_effects::Buf::align`]): grows left/top by less than 64 pixels.
+    fn align(&mut self, size: [f64; 2]) {
+        self.cpu(&mut |mut buf| {
+            buf.align(size);
+            buf
+        });
+    }
 }
 
 /// The CPU effect target (GPU chains go through [`Accelerator::effects`]: upload, readback).

crates/render/src/audio.rs

@@ -406,7 +406,7 @@ mod tests {
             pr.value = effectcraft_project::Value::Vec2([-6.0206, -96.0]);
         }
         let mut comp = comp;
-        comp.layers = vec![l1, l2];
+        comp.layers = vec![l1, l2].into();
         let cid = p.add_item("C", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(comp.into()));
         assert!(comp_has_audio(&p, cid));
         let rate = 1000;
@@ -452,11 +452,11 @@ mod tests {
         let base = Comp::new(64, 64, FrameRate::new(25, 1), Tick::from_seconds_f64(2.0));
         let tone = build::layer(&mut p, &base, "tone", LayerSource::Footage { item: fid }, (0, 0), None);
         let mut inner = base.clone();
-        inner.layers = vec![tone];
+        inner.layers = vec![tone].into();
         let inner_id = p.add_item("Inner", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(inner.into()));
         let pre = build::layer(&mut p, &base, "pre", LayerSource::Comp { item: inner_id }, (64, 64), None);
         let mut outer = base.clone();
-        outer.layers = vec![pre];
+        outer.layers = vec![pre].into();
         let outer_id = p.add_item("Outer", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(outer.into()));
         let rate = 8000;
         let t = Tick::from_seconds_f64(0.5);
@@ -483,7 +483,7 @@ mod tests {
         let mut tone = build::layer(&mut p, &base, "tone", LayerSource::Footage { item: fid }, (0, 0), None);
         tone.stretch = stretch;
         let mut comp = base.clone();
-        comp.layers = vec![tone];
+        comp.layers = vec![tone].into();
         let cid = p.add_item("C", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(comp.into()));
         let n = 2000usize;
         let t = Tick::from_seconds_f64(0.5);

crates/render/src/cache.rs

@@ -458,7 +458,7 @@ fn time_dependent(layer: &Layer, effects: bool) -> bool {
     if matches!(layer.source, LayerSource::Shape)
         && let Some(c) = layer.props.sub("contents")
     {
-        return group_has(c, "wiggle");
+        return group_has(c, "wiggle") || group_has(c, "wiggler");
     }
     // Wiggly selectors move with time; Expression selectors evaluate per character (their
     // property value alone doesn't capture the result).

crates/render/src/disk_cache.rs

@@ -1278,7 +1278,7 @@ mod tests {
         let f = Footage { path: "/virtual.mov".into(), width: 16, height: 9, duration: Tick::from_seconds_f64(1.0), has_video: true, ..Default::default() };
         let fid = p.add_item("virtual.mov", effectcraft_color::Label::None, None, ItemKind::Footage(f));
         let mut comp = Comp::new(16, 9, FrameRate::FPS_30, Tick::from_seconds_f64(1.0));
-        comp.layers = vec![build::layer(&mut p, &comp, "clip", LayerSource::Footage { item: fid }, (16, 9), None)];
+        comp.layers = vec![build::layer(&mut p, &comp, "clip", LayerSource::Footage { item: fid }, (16, 9), None)].into();
         let cid = p.add_item("C", effectcraft_color::Label::None, None, ItemKind::Comp(comp.into()));
 
         let id = |mark: u64| move |path: &str| (path == "/virtual.mov").then_some((8, mark));

crates/render/src/frames.rs

@@ -1,6 +1,7 @@
 use super::footage::NoFootage;
 use super::opts::RenderOpts;
-use super::{EvalCtx, Footage, FrameBlend, FrameRate, Image, ItemId, Layer, LayerSource, Project, Renderer, TICKS_PER_SECOND, Tick, shapes, text};
+use super::{Arc, EvalCtx, Footage, FrameBlend, FrameRate, Image, ItemId, Layer, LayerSource, Project, Renderer, TICKS_PER_SECOND, Tick, shapes, text};
+use rayon::prelude::*;
 
 /// The layer's frame blending mode, if the comp's Enable Frame Blending switch is on.
 /// One field of an interlaced frame as a full frame: the field's lines (`parity` 0 = even /
@@ -33,6 +34,23 @@ pub fn field_frame(img: &Image, parity: usize) -> Image {
     out
 }
 
+/// Interpret Footage ▸ Cineon Settings ▸ Logarithmic Conversion converts the log code values of
+/// a decoded (premultiplied) frame of `f` to the Current Gamma. When the conversion does not
+/// apply, the frame is returned unchanged.
+pub fn cineon_frame(img: Arc<Image>, f: &Footage) -> Arc<Image> {
+    if !f.cineon_applies() {
+        return img;
+    }
+    let cs = f.cineon;
+    let mut out = (*img).clone();
+    out.data.par_iter_mut().for_each(|p| {
+        let a = p[3];
+        let c = if a > 1e-6 { [p[0] / a, p[1] / a, p[2] / a] } else { [0.0; 3] }.map(|v| cs.convert(v));
+        *p = [c[0] * a, c[1] * a, c[2] * a, a];
+    });
+    Arc::new(out)
+}
+
 /// Interpret Footage ▸ Invert Alpha and Interpret As Linear Light on decoded (premultiplied)
 /// pixels; linear light is encoded in `space` ([`color::Pipe::linear_footage_space`]).
 pub fn interpret_pixels(img: &Image, f: &Footage, space: effectcraft_color::ColorSpace) -> Image {

crates/render/src/lib.rs

@@ -48,8 +48,8 @@ mod pipeline;
 pub use accel::{Accelerator, Backend, FxStep, FxTarget};
 pub use footage::{CancellableFootage, FloatCurve, FootageSource, NoFootage, is_vector_footage};
 pub use frames::{
-    adaptive_samples, blend_frames, content_bounds, extended_region, field_frame, frame_position, frame_size, interpret_pixels, kurbo_path, render_frame,
-    roi_inside,
+    adaptive_samples, blend_frames, cineon_frame, content_bounds, extended_region, field_frame, frame_position, frame_size, interpret_pixels, kurbo_path,
+    render_frame, roi_inside,
 };
 #[cfg(test)]
 use fx_host::FxHost;

crates/render/src/pipeline.rs

@@ -1,6 +1,6 @@
 use super::accel::{Accelerator, Backend, CpuFx, FxStep, FxTarget};
 use super::footage::{FootageSource, is_vector_footage};
-use super::frames::{blend_frames, content_bounds, field_frame, frame_blend_mode, frame_position, frame_size, interpret_pixels, roi_inside};
+use super::frames::{blend_frames, cineon_frame, content_bounds, field_frame, frame_blend_mode, frame_position, frame_size, interpret_pixels, roi_inside};
 use super::fx_host::{FxHost, essential_overrides};
 use super::opts::{Collapse3d, LayerTiming, MAX_THROUGH, RenderOpts, Through};
 use super::{
@@ -566,14 +566,26 @@ impl<'a> Renderer<'a> {
         let Some(fx) = layer.effects() else { return };
         let lt = layer.layer_time(ctx.time);
         let layer_size = ctx.effect_bounds(layer).0;
-        // #659: an authored layer's buffer spans only its painted content while the stack works
-        // on the layer's whole region (`layer_size`): give the buffer the room a sized source
-        // already has, so tiling or displacement can place pixels outside the content instead
-        // of losing them at its edge. Only when something will actually run, and not for an
-        // adjustment layer, whose buffer is the comp below and already spans it.
-        if !adjustment
-            && fx.groups().any(|g| g.enabled && matches!(&g.kind, GroupKind::Effect { effect } if effectcraft_effects::find(effect).is_some_and(|s| !effectcraft_effects::audio_fx::is_audio_effect(s.id)))) {
-            target.cover(layer_size);
+        // #659 / #1205: an authored layer's buffer spans only its painted content. Effects that
+        // place pixels outside it grow the buffer themselves, by exactly what they need
+        // (`layer_cover_pad`: CC Tiler, CC Smear, CC Mosaic sharp) instead of a blanket cover of
+        // the whole layer rectangle on every stack — which paid a comp-sized texture per layer,
+        // per frame in flight, for glow and blur that never use the extra room. The buffer still
+        // takes the cover's pixel-grid phase: a downscaled layer resamples along that grid.
+        // Effects not known to stay inside their own margins (Twirl, Bulge, Transform, ...) still
+        // get the cover: they move content past the painted bounds without growing the buffer.
+        let video = || {
+            fx.groups().filter(|g| g.enabled).filter_map(|g| match &g.kind {
+                GroupKind::Effect { effect } => effectcraft_effects::find(effect).filter(|s| !effectcraft_effects::audio_fx::is_audio_effect(s.id)),
+                _ => None,
+            })
+        };
+        if !adjustment && video().next().is_some() {
+            if video().all(|s| s.skips_cover()) {
+                target.align(layer_size);
+            } else {
+                target.cover(layer_size);
+            }
         }
         let mut mask_shapes = masks::shapes(ctx, layer);
         if origin != [0.0; 2] {
@@ -817,16 +829,17 @@ impl<'a> Renderer<'a> {
         if f.fields != effectcraft_project::FieldOrder::Off && matches!(f.kind, FootageKind::Video | FootageKind::Sequence) {
             let field_rate = FrameRate::new(f.frame_rate.num * 2, f.frame_rate.den);
             let i = field_rate.frame_at(t).max(0);
-            let img = self.footage.frame_with(item, f, f.frame_rate.tick_of(i / 2), None, self.pipe.float_curve(f))?;
+            let img = cineon_frame(self.footage.frame_with(item, f, f.frame_rate.tick_of(i / 2), None, self.pipe.float_curve(f))?, f);
             let dominant_upper = f.fields == effectcraft_project::FieldOrder::UpperFirst;
             // Upper field = even lines (0, 2, …).
             let parity = if (i % 2 == 0) == dominant_upper { 0 } else { 1 };
             return Some(Arc::new(interpret_pixels(&field_frame(&img, parity), f, self.pipe.linear_footage_space(f))));
         }
         // Interpretation is per pixel but not linear: it runs on the frame before resampling.
-        let size = size.filter(|_| !(f.invert_alpha || f.linear_light_applies()));
+        let per_pixel = f.invert_alpha || f.linear_light_applies();
+        let size = size.filter(|_| !(per_pixel || f.cineon_applies()));
         let img = self.footage_frame_raw(ctx, layer, item, f, t, size)?;
-        if f.invert_alpha || f.linear_light_applies() { Some(Arc::new(interpret_pixels(&img, f, self.pipe.linear_footage_space(f)))) } else { Some(img) }
+        if per_pixel { Some(Arc::new(interpret_pixels(&img, f, self.pipe.linear_footage_space(f)))) } else { Some(img) }
     }
 
     fn footage_frame_raw(&self, ctx: &EvalCtx, layer: &Layer, item: ItemId, f: &Footage, t: Tick, size: Option<(u32, u32)>) -> Option<Arc<Image>> {
@@ -844,6 +857,10 @@ impl<'a> Renderer<'a> {
                     if f.alpha == effectcraft_project::AlphaMode::Premultiplied {
                         f.premul_color.map(f32::to_bits).hash(&mut h);
                     }
+                    if f.cineon_applies() {
+                        let c = &f.cineon;
+                        [c.converted_black, c.converted_white, c.black, c.white, c.gamma, c.rolloff].map(f32::to_bits).hash(&mut h);
+                    }
                     h.finish()
                 });
                 if let (Some(c), Some(k)) = (self.cache, key)
@@ -851,8 +868,9 @@ impl<'a> Renderer<'a> {
                 {
                     return Some(Arc::new(b.img.clone()));
                 }
-                let a = self.footage.frame_with(item, f, f.frame_rate.tick_of(i), None, float);
-                let b = self.footage.frame_with(item, f, f.frame_rate.tick_of(i + 1), None, float);
+                // Log scans are converted before they blend: the conversion is not linear.
+                let a = self.footage.frame_with(item, f, f.frame_rate.tick_of(i), None, float).map(|a| cineon_frame(a, f));
+                let b = self.footage.frame_with(item, f, f.frame_rate.tick_of(i + 1), None, float).map(|b| cineon_frame(b, f));
                 if let (Some(a), Some(b)) = (a, b) {
                     let img = blend_frames(mode, &a, &b, w as f32);
                     if let (Some(c), Some(k)) = (self.cache_to_keep(), key) {
@@ -862,7 +880,7 @@ impl<'a> Renderer<'a> {
                 }
             }
         }
-        self.footage.frame_with(item, f, t, size, float)
+        self.footage.frame_with(item, f, t, size, float).map(|img| cineon_frame(img, f))
     }
 
     /// Source → masks, clamped/quantised to the project depth.

crates/render/src/shapes.rs

@@ -2,8 +2,8 @@
 //! with the After Effects stacking semantics:
 //!
 //! - path operators (Trim Paths, Round Corners, Offset Paths, Pucker & Bloat, Twist, Zig Zag,
-//!   Wiggle Paths, Merge Paths, Repeater) act on all paths above them in the same group, including
-//!   the paths of nested groups;
+//!   Wiggle Paths, Wiggle Transform, Merge Paths, Repeater) act on all paths above them in the
+//!   same group, including the paths of nested groups;
 //! - paint items (fills, strokes, gradient fills/strokes) paint the paths above them, *as modified
 //!   by every operator in the stack* — a Trim Paths below a Stroke still trims it;
 //! - items higher in the list draw on top;
@@ -17,7 +17,9 @@ use effectcraft_keyframe::{Gradient, Value};
 use effectcraft_path::{BezPath, Cap, FillRule, Join, StrokeStyle, ops, varstroke};
 use effectcraft_project::{Layer, Node, PropGroup};
 use effectcraft_raster::{Image, Mask};
+use effectcraft_text::selectors::{self, Wiggly};
 use rayon::prelude::*;
+use std::collections::{HashMap, HashSet};
 
 use crate::eval::EvalCtx;
 
@@ -185,9 +187,75 @@ fn used_slots(live: &[usize], draws: &[Draw]) -> Vec<usize> {
     v
 }
 
+/// Wiggle Transform: moves the live slots by a random offset of the Transform group's Anchor
+/// Point, Position, Scale and Rotation (the most each one wiggles), changing over time. Its
+/// Wiggles/Second, Correlation, Temporal Phase, Spatial Phase and Random Seed work as the Wiggly
+/// Selector's do, with each Repeater copy (`copy_of`) as one unit: the copies of a Repeater above
+/// the operation move on their own as far as Correlation allows, and the copies of a Repeater
+/// below it move as one. The four transformations of one operation move together.
+fn wiggle_transform(ctx: &EvalCtx, layer: &Layer, g: &PropGroup, arena: &mut [BezPath], live: &[usize], copy_of: &HashMap<usize, usize>, draws: &mut [Draw]) {
+    let Some(tr) = g.sub("transform") else { return };
+    let w = Wiggly {
+        max: 1.0,
+        min: -1.0,
+        wiggles_per_second: ctx.f(layer, g, "speed", 2.0),
+        correlation: ctx.f(layer, g, "correlation", 50.0) / 100.0,
+        temporal_phase: ctx.f(layer, g, "phase", 0.0),
+        spatial_phase: ctx.f(layer, g, "spatialPhase", 0.0),
+        lock_dimensions: false,
+        seed: ctx.f(layer, g, "seed", 0.0).round() as i64 as u64,
+    };
+    let anchor = ctx.v2(layer, tr, "anchor", [0.0; 2]);
+    let pos = ctx.v2(layer, tr, "position", [0.0; 2]);
+    let scale = ctx.v2(layer, tr, "scale", [0.0; 2]);
+    let rot = ctx.f(layer, tr, "rotation", 0.0);
+    let t = layer.layer_time(ctx.time).seconds();
+    let matrix = |k: usize| {
+        let (x, y) = (selectors::wiggly_value(&w, t, k, 0), selectors::wiggly_value(&w, t, k, 1));
+        Mat3::translate(vec2(pos[0] * x, pos[1] * y))
+            * Mat3::rotate_deg(rot * x)
+            * Mat3::scale(vec2(1.0 + scale[0] * x / 100.0, 1.0 + scale[1] * y / 100.0))
+            * Mat3::translate(vec2(-anchor[0] * x, -anchor[1] * y))
+    };
+    let mut by_copy: HashMap<usize, Mat3> = HashMap::new();
+    let mut done: HashSet<usize> = HashSet::new();
+    for &s in live {
+        if !done.insert(s) {
+            continue;
+        }
+        let k = copy_of.get(&s).copied().unwrap_or(0);
+        let m = *by_copy.entry(k).or_insert_with(|| matrix(k));
+        arena[s] = mat_path(&arena[s], &m);
+    }
+    // A paint above the operation whose paths all moved by one matrix moves its gradient and
+    // stroke scale with them, as a group transform does. A paint over copies that moved by
+    // different matrices stays one paint (its fill rule and opacity apply to all of them at once)
+    // and keeps its gradient and stroke scale.
+    for d in draws {
+        let mut ms = d.slots.iter().map(|s| done.contains(s).then(|| by_copy.get(&copy_of.get(s).copied().unwrap_or(0)).copied()).flatten());
+        let Some(Some(m)) = ms.next() else { continue };
+        if ms.all(|x| x == Some(m)) {
+            d.xf = m * d.xf;
+        }
+    }
+}
+
 /// Collect the draws of a contents group and the path slots live at its end (in group space).
 /// `arena` holds every path slot; operators rewrite slots in place.
 fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<BezPath>) -> (Vec<Draw>, Vec<usize>) {
+    collect_in(ctx, layer, contents, arena, &mut Copies::default())
+}
+
+/// The Repeater copy each path slot belongs to, for Wiggle Transform: `of` maps a slot a Repeater
+/// made to its copy's id (slots no Repeater made are copy 0). Ids are unique across the layer's
+/// groups, so copies made in a nested group stay apart in the groups around it.
+#[derive(Default)]
+struct Copies {
+    of: HashMap<usize, usize>,
+    next: usize,
+}
+
+fn collect_in(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<BezPath>, copy_ids: &mut Copies) -> (Vec<Draw>, Vec<usize>) {
     let mut draws: Vec<Draw> = Vec::new();
     let mut live: Vec<usize> = Vec::new();
     let opacity = |g: &PropGroup| (ctx.f(layer, g, "opacity", 100.0) / 100.0) as f32;
@@ -330,6 +398,7 @@ fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<B
                 let t = layer.layer_time(ctx.time).seconds();
                 apply(arena, &live, |p| ops::wiggle(p, &w, t));
             }
+            "wiggler" => wiggle_transform(ctx, layer, g, arena, &live, &copy_ids.of, &mut draws),
             "merge" => {
                 let mode = ops::MergeMode::from_index(ctx.e(layer, g, "mode"));
                 let input: Vec<BezPath> = live.iter().map(|&i| arena[i].clone()).collect();
@@ -342,7 +411,7 @@ fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<B
             }
             "group" => {
                 let Some(inner) = g.sub("contents") else { continue };
-                let (cd, cl) = collect(ctx, layer, inner, arena);
+                let (cd, cl) = collect_in(ctx, layer, inner, arena, copy_ids);
                 let (m, op) = g.sub("transform").map(|t| group_matrix(ctx, layer, t)).unwrap_or((Mat3::IDENTITY, 1.0));
                 for i in used_slots(&cl, &cd) {
                     arena[i] = mat_path(&arena[i], &m);
@@ -379,12 +448,20 @@ fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<B
                 // Each copy gets its own transformed slots, so operators below the repeater act on
                 // the repeated geometry (copy order: original first).
                 let mut copy_maps: Vec<std::collections::HashMap<usize, usize>> = Vec::with_capacity(n);
+                // Each copy of each earlier copy (a second Repeater) gets an id of its own.
+                let mut ids: HashMap<(usize, usize), usize> = HashMap::new();
                 for i in 0..n {
                     let m = step(i as f64 + offset);
                     let mut map = std::collections::HashMap::new();
                     for &s in &base_slots {
                         arena.push(mat_path(&arena[s], &m));
                         map.insert(s, arena.len() - 1);
+                        let base = copy_ids.of.get(&s).copied().unwrap_or(0);
+                        let id = *ids.entry((i, base)).or_insert_with(|| {
+                            copy_ids.next += 1;
+                            copy_ids.next
+                        });
+                        copy_ids.of.insert(arena.len() - 1, id);
                     }
                     live.extend(base_live.iter().map(|s| map[s]));
                     copy_maps.push(map);

crates/render/src/shapes/tests.rs

@@ -310,6 +310,202 @@ fn wiggle_paths_vary_over_time_deterministically() {
     assert_ne!(a.data, c.data);
 }
 
+/// Alpha-weighted centroid of the pixels in columns `x0..x1`.
+fn centroid(img: &Image, x0: i64, x1: i64) -> [f32; 2] {
+    let (mut sx, mut sy, mut sa) = (0.0, 0.0, 0.0);
+    for x in x0..x1 {
+        for y in 0..img.height as i64 {
+            let a = alpha(img, x, y);
+            sx += a * x as f32;
+            sy += a * y as f32;
+            sa += a;
+        }
+    }
+    [sx / sa, sy / sa]
+}
+
+fn wiggle_transform(ids: &mut Ids, params: &[(&str, Value)]) -> PropGroup {
+    op(ids, "wiggler", params)
+}
+
+#[test]
+fn wiggle_transform_moves_paths_over_time() {
+    let run = |position: [f64; 2], t: f64| {
+        let (p, cid) = shape_comp(|ids| {
+            let w = wiggle_transform(ids, &[("transform/position", Value::Vec2(position))]);
+            vec![build::shape_rect(ids, [20.0, 20.0], [0.0, 0.0], 0.0), w, build::shape_fill(ids, RED)]
+        });
+        render_frame(&p, cid, Tick::from_seconds_f64(t), 1.0)
+    };
+    // The defaults wiggle nothing: the square stays centered on pixel 99.5, 49.5.
+    let rest = [99.5, 49.5];
+    assert_eq!(centroid(&run([0.0, 0.0], 0.37), 0, 200), rest);
+    let a = run([15.0, 15.0], 0.37);
+    assert_eq!(a.data, run([15.0, 15.0], 0.37).data, "the same time gives the same frame");
+    let b = run([15.0, 15.0], 1.21);
+    let (ca, cb) = (centroid(&a, 0, 200), centroid(&b, 0, 200));
+    assert!(ca != rest && ca != cb, "{ca:?} {cb:?}");
+    for c in [ca, cb] {
+        assert!((c[0] - rest[0]).abs() <= 15.01 && (c[1] - rest[1]).abs() <= 15.01, "{c:?}");
+    }
+    // A translation keeps the square's area.
+    assert!((coverage(&a) - 400.0).abs() < 1.0, "{}", coverage(&a));
+    // The layer cache keys a layer with a Wiggle Transform by time.
+    let (p, cid) = shape_comp(|ids| vec![build::shape_rect(ids, [20.0, 20.0], [0.0, 0.0], 0.0), wiggle_transform(ids, &[]), build::shape_fill(ids, RED)]);
+    let comp = p.comp(cid).unwrap();
+    let key = |t: f64| crate::cache::layer_key(&crate::eval::EvalCtx::new(&p, cid, comp, Tick::from_seconds_f64(t)), &comp.layers[0], 1.0, false, false);
+    assert_ne!(key(0.37), key(1.21));
+}
+
+#[test]
+fn wiggle_transform_scales_and_rotates() {
+    let run = |params: &[(&str, Value)]| {
+        let (p, cid) = shape_comp(|ids| {
+            let w = wiggle_transform(ids, params);
+            vec![build::shape_rect(ids, [40.0, 40.0], [0.0, 0.0], 0.0), w, build::shape_fill(ids, RED)]
+        });
+        render_frame(&p, cid, Tick::from_seconds_f64(0.37), 1.0)
+    };
+    let scaled = coverage(&run(&[("transform/scale", Value::Vec2([50.0, 50.0]))]));
+    assert!((scaled - 1600.0).abs() > 20.0, "{scaled}");
+    let rotated = run(&[("transform/rotation", Value::Scalar(45.0))]);
+    assert!((coverage(&rotated) - 1600.0).abs() < 2.0, "{}", coverage(&rotated));
+    assert!(alpha(&rotated, 81, 31) < 0.5 || alpha(&rotated, 119, 31) < 0.5, "a corner turned away");
+}
+
+/// A gradient above a Wiggle Transform moves with the paths it paints, as under a group transform.
+#[test]
+fn wiggle_transform_moves_the_gradient_with_the_path() {
+    let (p, cid) = shape_comp(|ids| {
+        let g = Gradient { colors: vec![(0.0, [0.0, 0.0, 0.0, 1.0]), (1.0, [1.0, 1.0, 1.0, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 1.0)] };
+        vec![
+            build::shape_rect(ids, [40.0, 40.0], [0.0, 0.0], 0.0),
+            build::shape_gradient_fill(ids, false, [-20.0, 0.0], [20.0, 0.0], g),
+            wiggle_transform(ids, &[("transform/position", Value::Vec2([60.0, 0.0]))]),
+        ]
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.37), 1.0);
+    let cols: Vec<i64> = (0..200).filter(|&x| alpha(&img, x, 50) > 0.99).collect();
+    let (l, r) = (cols[0], cols[cols.len() - 1]);
+    assert!((l - 80).abs() > 3, "the square moved: {l}");
+    let (cl, cr) = (img.get(l, 50), img.get(r, 50));
+    assert!(cl[0] < 0.1 && cr[0] > 0.9, "the ramp runs edge to edge: {cl:?} {cr:?}");
+}
+
+/// A gradient that paints every copy of a Repeater moves with the copies when they wiggle alike
+/// (Correlation 100).
+#[test]
+fn wiggle_transform_moves_a_gradient_shared_by_repeater_copies() {
+    let (p, cid) = shape_comp(|ids| {
+        let g = Gradient { colors: vec![(0.0, [0.0, 0.0, 0.0, 1.0]), (1.0, [1.0, 1.0, 1.0, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 1.0)] };
+        vec![
+            build::shape_rect(ids, [20.0, 20.0], [-60.0, 0.0], 0.0),
+            build::shape_repeater(ids, 3.0, [60.0, 0.0]),
+            build::shape_gradient_fill(ids, false, [0.0, -10.0], [0.0, 10.0], g),
+            wiggle_transform(ids, &[("correlation", Value::Scalar(100.0)), ("transform/position", Value::Vec2([0.0, 15.0]))]),
+        ]
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.9), 1.0);
+    for cx in [40, 100, 160] {
+        let rows: Vec<i64> = (0..100).filter(|&y| alpha(&img, cx, y) > 0.99).collect();
+        let (t, b) = (rows[0], rows[rows.len() - 1]);
+        assert!((t - 40).abs() > 3, "copy at {cx} moved: {t}");
+        let (ct, cb) = (img.get(cx, t), img.get(cx, b));
+        assert!(ct[0] < 0.1 && cb[0] > 0.9, "copy at {cx}: {ct:?} {cb:?}");
+    }
+}
+
+/// A gradient over copies that wiggle on their own keeps its place: every copy shows the ramp's
+/// middle at the group's origin row.
+#[test]
+fn wiggle_transform_keeps_a_gradient_over_copies_wiggling_apart() {
+    let (p, cid) = shape_comp(|ids| {
+        let g = Gradient { colors: vec![(0.0, [0.0, 0.0, 0.0, 1.0]), (1.0, [1.0, 1.0, 1.0, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 1.0)] };
+        vec![
+            build::shape_rect(ids, [20.0, 40.0], [-60.0, 0.0], 0.0),
+            build::shape_repeater(ids, 3.0, [60.0, 0.0]),
+            build::shape_gradient_fill(ids, false, [0.0, -20.0], [0.0, 20.0], g),
+            wiggle_transform(ids, &[("correlation", Value::Scalar(0.0)), ("transform/position", Value::Vec2([0.0, 15.0]))]),
+        ]
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.9), 1.0);
+    for cx in [40, 100, 160] {
+        let c = img.get(cx, 50);
+        assert!(c[3] > 0.99 && (c[0] - 0.5).abs() < 0.05, "copy at {cx}: {c:?}");
+    }
+}
+
+/// Copies wiggling on their own under one 50 % fill stay one paint: where they overlap, the fill
+/// covers them once.
+#[test]
+fn wiggle_transform_keeps_one_fill_over_overlapping_copies() {
+    let (p, cid) = shape_comp(|ids| {
+        let mut fill = build::shape_fill(ids, RED);
+        set(&mut fill, "opacity", Value::Scalar(50.0));
+        vec![
+            build::shape_rect(ids, [40.0, 40.0], [-20.0, 0.0], 0.0),
+            build::shape_repeater(ids, 3.0, [20.0, 0.0]),
+            fill,
+            wiggle_transform(ids, &[("correlation", Value::Scalar(0.0)), ("transform/position", Value::Vec2([0.0, 15.0]))]),
+        ]
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.9), 1.0);
+    let top = img.data.iter().map(|px| px[3]).fold(0.0f32, f32::max);
+    assert!((top - 0.5).abs() < 0.01, "{top}");
+}
+
+/// A long stack of Repeaters, each cleared by a zero-copy Repeater, still renders the last Repeater's copies.
+#[test]
+fn long_repeater_stack_with_cleared_copies_renders() {
+    let (p, cid) = shape_comp(|ids| {
+        let mut items = vec![];
+        for _ in 0..70 {
+            items.push(build::shape_rect(ids, [20.0, 20.0], [0.0, 0.0], 0.0));
+            items.push(build::shape_repeater(ids, 3.0, [10.0, 0.0]));
+            items.push(build::shape_repeater(ids, 0.0, [10.0, 0.0]));
+        }
+        items.push(build::shape_rect(ids, [20.0, 20.0], [0.0, 0.0], 0.0));
+        items.push(build::shape_repeater(ids, 3.0, [30.0, 0.0]));
+        items.push(wiggle_transform(ids, &[("correlation", Value::Scalar(0.0)), ("transform/position", Value::Vec2([0.0, 15.0]))]));
+        items.push(build::shape_fill(ids, RED));
+        items
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.37), 1.0);
+    assert!((coverage(&img) - 1200.0).abs() < 2.0, "{}", coverage(&img));
+}
+
+/// Copies a Repeater makes above a Wiggle Transform wiggle on their own (Correlation 0) or as one
+/// (Correlation 100); with the Wiggle Transform above the Repeater every copy wiggles the same.
+#[test]
+fn wiggle_transform_and_repeater_order() {
+    let offsets = |wiggle_first: bool, correlation: f64| {
+        let (p, cid) = shape_comp(|ids| {
+            let rect = build::shape_rect(ids, [20.0, 20.0], [-60.0, 0.0], 0.0);
+            let rep = build::shape_repeater(ids, 3.0, [60.0, 0.0]);
+            let w = wiggle_transform(ids, &[("correlation", Value::Scalar(correlation)), ("transform/position", Value::Vec2([0.0, 15.0]))]);
+            let fill = build::shape_fill(ids, RED);
+            if wiggle_first { vec![rect, w, rep, fill] } else { vec![rect, rep, w, fill] }
+        });
+        let img = render_frame(&p, cid, Tick::from_seconds_f64(0.37), 1.0);
+        [(0, 70), (70, 130), (130, 200)].map(|(x0, x1)| centroid(&img, x0, x1)[1] - 50.0)
+    };
+    let own = offsets(false, 0.0);
+    assert!((own[0] - own[1]).abs() > 0.5 || (own[1] - own[2]).abs() > 0.5, "copies wiggle on their own: {own:?}");
+    // A Repeater inside a group above the Wiggle Transform: its copies still wiggle on their own.
+    let (p, cid) = shape_comp(|ids| {
+        let inner = vec![build::shape_rect(ids, [20.0, 20.0], [-60.0, 0.0], 0.0), build::shape_repeater(ids, 3.0, [60.0, 0.0]), build::shape_fill(ids, RED)];
+        let group = build::shape_group(ids, "Repeated", inner);
+        vec![group, wiggle_transform(ids, &[("correlation", Value::Scalar(0.0)), ("transform/position", Value::Vec2([0.0, 15.0]))])]
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.37), 1.0);
+    let nested = [(0, 70), (70, 130), (130, 200)].map(|(x0, x1)| centroid(&img, x0, x1)[1] - 50.0);
+    assert!((nested[0] - nested[1]).abs() > 0.5 || (nested[1] - nested[2]).abs() > 0.5, "nested copies: {nested:?}");
+    for same in [offsets(false, 100.0), offsets(true, 0.0)] {
+        assert!(same[0].abs() > 0.5, "{same:?}");
+        assert!((same[0] - same[1]).abs() < 0.05 && (same[1] - same[2]).abs() < 0.05, "copies wiggle as one: {same:?}");
+    }
+}
+
 #[test]
 fn zigzag_and_twist_render() {
     let (p, cid) = shape_comp(|ids| {

crates/render/src/tests.rs

@@ -314,7 +314,7 @@ fn particle_world_scene(pan: f64) -> (Project, ItemId) {
         let Value::Vec3(v) = pr.value else { panic!("{path}: {:?}", pr.value) };
         pr.value = Value::Vec3([v[0] + pan, v[1], v[2]]);
     }
-    p.comp_mut(cid).unwrap().layers = vec![cam, l];
+    p.comp_mut(cid).unwrap().layers = vec![cam, l].into();
     (p, cid)
 }
 
@@ -373,7 +373,7 @@ fn burst_scene_keys(cut: Option<f64>, start: f64, stretch: f64, hold: bool) -> (
     l.in_point = l.start_time;
     l.out_point = Tick::from_seconds_f64(4.0);
     l.stretch = stretch;
-    p.comp_mut(cid).unwrap().layers = vec![l];
+    p.comp_mut(cid).unwrap().layers = vec![l].into();
     (p, cid)
 }
 
@@ -507,7 +507,7 @@ fn system_scene(id: &str, rate: Option<f64>) -> (Project, ItemId) {
         let key = |t: f64, v: f64| Keyframe::new(Tick::from_seconds_f64(t), Value::Scalar(v));
         fx.unwrap().prop_mut("birthRate").unwrap().keys = vec![key(0.0, 3.0), key(0.5, 3.0), key(0.5 + 1.0 / 30.0, 0.0)];
     }
-    p.comp_mut(cid).unwrap().layers = vec![l];
+    p.comp_mut(cid).unwrap().layers = vec![l].into();
     (p, cid)
 }
 
@@ -614,7 +614,7 @@ fn cache_scene() -> (Project, ItemId) {
         vec![Keyframe::new(Tick::ZERO, Value::Vec3([20.0, 70.0, 0.0])), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Vec3([120.0, 70.0, 0.0]))];
     add_effect_200(&mut p, &mut text, "ec.blur.gaussian", &[("blurriness", Value::Scalar(6.0))]);
     let c = p.comp_mut(cid).unwrap();
-    c.layers = vec![text, shape, bg];
+    c.layers = vec![text, shape, bg].into();
     (p, cid)
 }
 
@@ -854,7 +854,7 @@ fn edge_pinning_displaces_all_of_a_centred_shape_layer() {
         p.comp_mut(cid).unwrap().layers.push(l.clone());
         let plain = render_frame(&p, cid, Tick::ZERO, 1.0);
         add_effect_200(&mut p, &mut l, id, &vals);
-        p.comp_mut(cid).unwrap().layers = vec![l];
+        p.comp_mut(cid).unwrap().layers = vec![l].into();
         let warped = render_frame(&p, cid, Tick::ZERO, 1.0);
         // Alpha change per comp quadrant (TL, TR, BL, BR): the rectangle's edges move in each.
         let mut q = [0.0f32; 4];
@@ -888,7 +888,7 @@ fn default_effect_points_sit_at_the_centre_of_a_shape_layer() {
         p.comp_mut(cid).unwrap().layers.push(l.clone());
         let plain = render_frame(&p, cid, Tick::ZERO, 1.0);
         add_effect_200(&mut p, &mut l, id, &vals);
-        p.comp_mut(cid).unwrap().layers = vec![l];
+        p.comp_mut(cid).unwrap().layers = vec![l].into();
         let warped = render_frame(&p, cid, Tick::ZERO, 1.0);
         // Alpha change per comp quadrant (TL, TR, BL, BR): the top and bottom edges move in each.
         let mut q = [0.0f32; 4];
@@ -917,7 +917,7 @@ fn effects_on_text_reach_past_the_text_bounds() {
     let plain = render_frame(&p, cid, Tick::ZERO, 1.0);
     let painted = plain.data.iter().filter(|px| px[3] > 0.5).count();
     add_effect_200(&mut p, &mut l, "ec.distort.cctiler", &[("scale", Value::Scalar(25.0))]);
-    p.comp_mut(cid).unwrap().layers = vec![l];
+    p.comp_mut(cid).unwrap().layers = vec![l].into();
     let tiled = render_frame(&p, cid, Tick::ZERO, 1.0);
     let (mut lo, mut hi) = (u32::MAX, 0u32);
     for y in 0..100 {
@@ -951,7 +951,7 @@ fn cc_smear_trails_text_past_its_bounds() {
         "ec.distort.ccsmear",
         &[("from", Value::Vec2([110.0, 45.0])), ("to", Value::Vec2([185.0, 45.0])), ("reach", Value::Scalar(100.0)), ("radius", Value::Scalar(40.0))],
     );
-    p.comp_mut(cid).unwrap().layers = vec![l];
+    p.comp_mut(cid).unwrap().layers = vec![l].into();
     let smeared = right(&render_frame(&p, cid, Tick::ZERO, 1.0));
     assert!(plain > 40 && smeared > plain + 25, "CC Smear trails the glyphs past the text bounds: right edge {plain} → {smeared}");
 }
@@ -974,7 +974,7 @@ fn layer_parameters_see_a_whole_shape_layer() {
     let matte_id = shape.id;
     let mut s = solid(&mut p, &comp, [0.0, 0.0, 1.0], 200, 100);
     add_effect_200(&mut p, &mut s, "ec.channel.setmatte", &[("takeMatteFromLayer", Value::Layer(Some(matte_id.0)))]);
-    p.comp_mut(cid).unwrap().layers = vec![s, shape];
+    p.comp_mut(cid).unwrap().layers = vec![s, shape].into();
     let f = render_frame(&p, cid, Tick::ZERO, 1.0);
     // The matte covers x 50..150, y 25..75: kept inside (all four quadrants), gone outside.
     for (x, y) in [(60, 30), (140, 30), (60, 70), (140, 70)] {
@@ -1064,7 +1064,7 @@ fn self_inputs_share_source_semantics_across_effects_and_times() {
         "ec.channel.blend",
         &[("blendWithLayer", Value::Layer(Some(id))), ("blendWithLayerSource", Value::Enum(0)), ("blendWithOriginal", Value::Scalar(0.0))],
     );
-    p.comp_mut(cid).unwrap().layers = vec![l];
+    p.comp_mut(cid).unwrap().layers = vec![l].into();
     let c = p.comp(cid).unwrap();
     let ctx = crate::eval::EvalCtx::new(&p, cid, c, Tick::ZERO);
     assert!(crate::cache::input_key(&ctx, &c.layers[0], 1.0, false, false, 1).is_some());
@@ -1082,7 +1082,7 @@ fn timed_source_reads_preserve_other_layer_masks() {
     let mask = build::mask(&mut Ids(&mut next), "Left", ShapePath::rect([50.0, 50.0], 80.0, 80.0), MaskMode::Add, [255, 255, 0]);
     p.next_id = next;
     other.props.sub_mut("masks").unwrap().children.push(mask.into());
-    p.comp_mut(cid).unwrap().layers = vec![owner.clone(), other.clone()];
+    p.comp_mut(cid).unwrap().layers = vec![owner.clone(), other.clone()].into();
     let ctx = crate::EvalCtx::new(&p, cid, p.comp(cid).unwrap(), Tick::ZERO);
     let renderer = crate::Renderer::new(&p, &crate::NoFootage, crate::RenderOpts::default());
     let host = crate::FxHost { r: &renderer, ctx: &ctx, layer: &owner, origin: [0.0; 2], index: Default::default(), original: None };
@@ -1103,7 +1103,7 @@ fn layer_dependencies_remain_cacheable_and_invalidate_only_related_edits() {
     let unrelated = solid(&mut p, &comp, [0.2, 0.3, 0.4], 200, 100);
     add_effect_200(&mut p, &mut source, "ec.channel.blend", &[("blendWithLayer", Value::Layer(Some(third.id.0))), ("blendWithOriginal", Value::Scalar(0.0))]);
     add_effect_200(&mut p, &mut owner, "ec.channel.blend", &[("blendWithLayer", Value::Layer(Some(source.id.0))), ("blendWithOriginal", Value::Scalar(0.0))]);
-    p.comp_mut(cid).unwrap().layers = vec![owner, source, third, unrelated];
+    p.comp_mut(cid).unwrap().layers = vec![owner, source, third, unrelated].into();
     let key = |p: &Project, time: f64, limit| {
         let comp = p.comp(cid).unwrap();
         let ctx = crate::EvalCtx::new(p, cid, comp, Tick::from_seconds_f64(time));
@@ -1144,12 +1144,12 @@ fn precomp_dependencies_hash_nested_sources_and_evaluated_animation() {
     child.props.prop_mut("transform/opacity").unwrap().keys =
         vec![Keyframe::new(Tick::ZERO, Value::Scalar(100.0)), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Scalar(50.0))];
     let mut nested = comp.clone();
-    nested.layers = vec![child];
+    nested.layers = vec![child].into();
     let nested_id = p.add_item("Nested", Label::Sandstone, None, ItemKind::Comp(nested.into()));
     let pre = build::layer(&mut p, &comp, "Precomp", LayerSource::Comp { item: nested_id }, (200, 100), None);
     let mut owner = solid(&mut p, &comp, [1.0, 0.0, 0.0], 200, 100);
     add_effect_200(&mut p, &mut owner, "ec.channel.blend", &[("blendWithLayer", Value::Layer(Some(pre.id.0))), ("blendWithOriginal", Value::Scalar(0.0))]);
-    p.comp_mut(cid).unwrap().layers = vec![owner, pre];
+    p.comp_mut(cid).unwrap().layers = vec![owner, pre].into();
     let key = |p: &Project, time| {
         let c = p.comp(cid).unwrap();
         crate::cache::layer_key(&crate::EvalCtx::new(p, cid, c, time), &c.layers[0], 1.0, false, false).unwrap()
@@ -1224,7 +1224,7 @@ fn scene_reader_dependency(pan: f64) -> (Project, ItemId) {
         let Value::Vec3(v) = pr.value else { panic!("{path}: {:?}", pr.value) };
         pr.value = Value::Vec3([v[0] + pan, v[1], v[2]]);
     }
-    p.comp_mut(cid).unwrap().layers = vec![cam, owner, source];
+    p.comp_mut(cid).unwrap().layers = vec![cam, owner, source].into();
     (p, cid)
 }
 
@@ -1336,7 +1336,7 @@ fn instance_scene(pan: f64) -> (Project, ItemId) {
     }
     let mut owner = solid(&mut p, &comp, [1.0, 1.0, 1.0], 200, 100);
     add_effect_200(&mut p, &mut owner, "ec.3d.instance3d", &[("layer", Value::Layer(Some(model.id.0)))]);
-    p.comp_mut(cid).unwrap().layers = vec![cam, owner, model];
+    p.comp_mut(cid).unwrap().layers = vec![cam, owner, model].into();
     (p, cid)
 }
 

crates/render/src/tests/audio_fx.rs

@@ -78,7 +78,7 @@ fn comp_with(id: Option<&str>, vals: &[(&str, Value)], solid: bool) -> (Project,
         l.props.sub_mut("effects").unwrap().children.push(g.into());
     }
     let mut comp = comp;
-    comp.layers = vec![l];
+    comp.layers = vec![l].into();
     let cid = p.add_item("C", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(comp.into()));
     (p, cid)
 }
@@ -272,7 +272,7 @@ fn audio_spectrum_follows_time_through_the_layer_cache() {
     g.prop_mut("audioLayer").unwrap().value = Value::Layer(Some(a.id.0));
     s.props.sub_mut("effects").unwrap().children.push(g.into());
     let mut comp = comp;
-    comp.layers = vec![s, a];
+    comp.layers = vec![s, a].into();
     let cid = p.add_item("C", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(comp.into()));
 
     let src = Signal(late_tone);

crates/render/src/tests/collapse.rs

@@ -53,17 +53,17 @@ fn scene(collapse: bool, flatten: bool) -> (Project, ItemId) {
         a.parent = Some(null.id);
         b.parent = Some(null.id);
         let mut c = outer.clone();
-        c.layers = vec![null, b, a, bg];
+        c.layers = vec![null, b, a, bg].into();
         p.add_item("Outer", Label::Sandstone, None, ItemKind::Comp(c.into()))
     } else {
         let mut inner = inner;
-        inner.layers = vec![b, a];
+        inner.layers = vec![b, a].into();
         let iid = p.add_item("Inner", Label::Sandstone, None, ItemKind::Comp(inner.into()));
         let mut pre = build::layer(&mut p, &outer, "Inner", LayerSource::Comp { item: iid }, (100, 100), None);
         xf(&mut pre);
         pre.switches.collapse = collapse;
         let mut c = outer.clone();
-        c.layers = vec![pre, bg];
+        c.layers = vec![pre, bg].into();
         p.add_item("Outer", Label::Sandstone, None, ItemKind::Comp(c.into()))
     };
     (p, cid)
@@ -154,7 +154,7 @@ fn referenced_layer_overrides_change_the_owner_cache_key() {
     p.next_id = next;
     b.props.sub_mut("effects").unwrap().children.push(fx.into());
     let mut c = comp;
-    c.layers = vec![b, a];
+    c.layers = vec![b, a].into();
     let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
     let comp = p.comp(cid).unwrap();
     let b = comp.layer(bid).unwrap();
@@ -182,7 +182,7 @@ fn collapsed_3d_layers_join_the_parent_scene() {
         let mut blue = solid(&mut p, &inner, [0.0, 0.0, 1.0], (60, 60), [100.0, 100.0, -200.0]);
         blue.switches.three_d = true;
         let mut inner = inner;
-        inner.layers = vec![blue];
+        inner.layers = vec![blue].into();
         let iid = p.add_item("Inner", Label::Sandstone, None, ItemKind::Comp(inner.into()));
         let mut pre = build::layer(&mut p, &outer, "Inner", LayerSource::Comp { item: iid }, (200, 200), None);
         pre.switches.three_d = true;
@@ -190,7 +190,7 @@ fn collapsed_3d_layers_join_the_parent_scene() {
         let mut red = solid(&mut p, &outer, [1.0, 0.0, 0.0], (100, 100), [100.0, 100.0, 0.0]);
         red.switches.three_d = true;
         let mut c = outer;
-        c.layers = vec![red, pre];
+        c.layers = vec![red, pre].into();
         let cid = p.add_item("Outer", Label::Sandstone, None, ItemKind::Comp(c.into()));
         render_frame(&p, cid, Tick::ZERO, 1.0).get(100, 100)
     };
@@ -228,11 +228,11 @@ fn scaled_square(cr: bool, via_parent: bool) -> Image {
         set(&mut null, "transform/scale", Value::Vec3([800.0, 800.0, 100.0]));
         set(&mut l, "transform/position", Value::Vec3([0.0, 0.0, 0.0]));
         l.parent = Some(null.id);
-        c.layers = vec![l, null];
+        c.layers = vec![l, null].into();
     } else {
         set(&mut l, "transform/position", Value::Vec3([100.3, 100.3, 0.0]));
         set(&mut l, "transform/scale", Value::Vec3([800.0, 800.0, 100.0]));
-        c.layers = vec![l];
+        c.layers = vec![l].into();
     }
     let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
     render_frame(&p, cid, Tick::ZERO, 1.0)
@@ -261,7 +261,7 @@ fn wireframe_quality_draws_the_layer_bounds() {
     let mut l = solid(&mut p, &comp, [1.0, 0.0, 0.0], (40, 40), [50.0, 50.0, 0.0]);
     l.switches.quality = Quality::Wireframe;
     let mut c = comp;
-    c.layers = vec![l];
+    c.layers = vec![l].into();
     let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
     let img = render_frame(&p, cid, Tick::ZERO, 1.0);
     assert_eq!(img.get(50, 50)[3], 0.0, "no fill");
@@ -272,7 +272,7 @@ fn wireframe_quality_draws_the_layer_bounds() {
     let mut l = solid(&mut p, &comp, [1.0, 1.0, 1.0], (40, 40), [50.5, 50.0, 0.0]);
     l.switches.quality = Quality::Draft;
     let mut c = comp;
-    c.layers = vec![l];
+    c.layers = vec![l].into();
     let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
     let img = render_frame(&p, cid, Tick::ZERO, 1.0);
     assert!(img.data.iter().all(|q| q[3] == 0.0 || q[3] == 1.0));
@@ -290,13 +290,13 @@ fn collapsed_precomp_of_another_size_renders_through_the_parent_camera() {
         let mut blue = solid(&mut p, &inner, [0.0, 0.0, 1.0], (40, 40), [500.0, 300.0, 0.0]);
         blue.switches.three_d = true;
         let mut inner = inner;
-        inner.layers = vec![blue];
+        inner.layers = vec![blue].into();
         let iid = p.add_item("Scene", Label::Sandstone, None, ItemKind::Comp(inner.into()));
         let mut pre = build::layer(&mut p, &outer, "Scene", LayerSource::Comp { item: iid }, (1000, 600), None);
         pre.switches.three_d = three_d_precomp;
         pre.switches.collapse = true;
         let mut c = outer.clone();
-        c.layers = vec![pre];
+        c.layers = vec![pre].into();
         if camera {
             let cam = build::layer(&mut p, &outer, "Camera", LayerSource::Camera, (300, 200), None);
             c.layers.insert(0, cam);
@@ -327,7 +327,7 @@ fn text_scaled_up_stays_sharp_without_the_switch() {
         set(&mut l, "transform/scale", Value::Vec3([scale, scale, 100.0]));
         assert!(!l.switches.collapse);
         let mut c = comp;
-        c.layers = vec![l];
+        c.layers = vec![l].into();
         let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
         render_frame(&p, cid, Tick::ZERO, 1.0)
     };
@@ -351,7 +351,7 @@ fn unscaled_text_rasterises_at_the_output_scale() {
     let mut comp = Comp::new(240, 160, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
     let mut l = build::layer(&mut p, &comp, "Text", LayerSource::Text, (240, 160), None);
     l.props.prop_mut("text/sourceText").unwrap().value = Value::Text(Box::new(TextDoc { text: "HE".into(), size: 30.0, ..Default::default() }));
-    comp.layers = vec![l];
+    comp.layers = vec![l].into();
     let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.into()));
     for i in 0..500 {
         let pos = [3.1 + i as f64 * 0.37, 7.3 + i as f64 * 0.29, 0.0];
@@ -387,7 +387,7 @@ fn effects_on_a_scaled_shape_follow_its_scale() {
         set(&mut l, "transform/position", Value::Vec3([100.0, 100.0, 0.0]));
         set(&mut l, "transform/scale", Value::Vec3([scale, scale, 100.0]));
         let mut c = comp;
-        c.layers = vec![l];
+        c.layers = vec![l].into();
         let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
         render_frame(&p, cid, Tick::ZERO, 1.0)
     };

crates/render/src/tests/guides.rs

@@ -40,7 +40,7 @@ fn scene(nest: Nest) -> (Project, ItemId, ItemId) {
     guide.switches.guide = true;
     let bg = solid(&mut p, &inner, [1.0, 0.0, 0.0], (100, 100), three_d);
     let mut inner = inner;
-    inner.layers = vec![guide, bg];
+    inner.layers = vec![guide, bg].into();
     let iid = p.add_item("Inner", Label::Sandstone, None, ItemKind::Comp(inner.into()));
     let mut outer = Comp::new(100, 100, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
     if matches!(nest, Nest::CollapsedAdvanced) {
@@ -49,7 +49,7 @@ fn scene(nest: Nest) -> (Project, ItemId, ItemId) {
     let mut pre = build::layer(&mut p, &outer, "Inner", LayerSource::Comp { item: iid }, (100, 100), None);
     pre.switches.collapse = !matches!(nest, Nest::Precomp);
     pre.switches.three_d = three_d;
-    outer.layers = vec![pre];
+    outer.layers = vec![pre].into();
     let oid = p.add_item("Outer", Label::Sandstone, None, ItemKind::Comp(outer.into()));
     (p, iid, oid)
 }

crates/render/src/tests/motion_tile.rs

@@ -58,7 +58,7 @@ fn adjustment_scene(out: f64, scale: f64) -> (Project, ItemId) {
     tile_then_scale(&mut p, &mut adj, out, scale);
     let mut layers = vec![adj];
     layers.extend(picture(&mut p, &comp));
-    p.comp_mut(cid).unwrap().layers = layers;
+    p.comp_mut(cid).unwrap().layers = layers.into();
     (p, cid)
 }
 
@@ -68,7 +68,7 @@ fn layer_scene(out: f64, scale: f64) -> (Project, ItemId) {
     let inner = Comp::new(W, H, FrameRate::FPS_30, Tick::from_seconds_f64(1.0));
     let iid = p.add_item("Picture", Label::Sandstone, None, ItemKind::Comp(inner.clone().into()));
     let layers = picture(&mut p, &inner);
-    p.comp_mut(iid).unwrap().layers = layers;
+    p.comp_mut(iid).unwrap().layers = layers.into();
     let mut pre = build::layer(&mut p, &comp, "Picture", LayerSource::Comp { item: iid }, (W, H), None);
     tile_then_scale(&mut p, &mut pre, out, scale);
     p.comp_mut(cid).unwrap().layers.push(pre);
@@ -151,7 +151,7 @@ fn adjustment_motion_tile_matches_the_after_effects_frames() {
             }
             adj.props.sub_mut("effects").unwrap().children.push(g.into());
         }
-        p.comp_mut(cid).unwrap().layers = vec![adj, red];
+        p.comp_mut(cid).unwrap().layers = vec![adj, red].into();
         // Quarter resolution: comp pixel (x, y) is output pixel (x / 4, y / 4).
         let img = render_frame(&p, cid, Tick::ZERO, 0.25);
         let at = |x: f64, y: f64| img.get((x / 4.0) as i64, (y / 4.0) as i64);

crates/render/src/tests/roi.rs

@@ -29,7 +29,7 @@ fn project(three_d: bool) -> (Project, effectcraft_project::ItemId) {
         }
         layers.push(l);
     }
-    p.comp_mut(cid).unwrap().layers = layers;
+    p.comp_mut(cid).unwrap().layers = layers.into();
     (p, cid)
 }
 

crates/render/src/tests/styles.rs

@@ -44,7 +44,7 @@ fn scene(color: [f32; 3], bg: Option<[f32; 3]>, f: impl FnOnce(&mut Project, &Co
     if let Some(bg) = bg {
         layers.push(solid(&mut p, &comp, bg, 200, 100));
     }
-    p.comp_mut(cid).unwrap().layers = layers;
+    p.comp_mut(cid).unwrap().layers = layers.into();
     (p, cid)
 }
 

crates/render/src/three_d/adv/raster.rs

@@ -13,7 +13,7 @@ use std::collections::BinaryHeap;
 
 use rayon::prelude::*;
 
-use super::scene::{Scene, ShadowMap, Vertex};
+use super::scene::{EnvInfo, Scene, ShadowMap, Vertex};
 use super::shade::{Frag, sample, shade};
 
 /// A rendered target at raster size.
@@ -500,11 +500,39 @@ pub(crate) fn shadow_sizes(width: u32, height: u32, draft: bool, kinds: &[u32])
     sizes.into_iter().map(|z| (z > 0).then_some(z)).collect()
 }
 
-/// Build the shadow maps of every shadow-casting light (lights marked `shadow == 0`).
+/// The Environment light's shadow map: one orthographic map over the scene's bounding sphere
+/// from its dominant direction (the light travels from the bright region into the scene), like
+/// a parallel light's.
+fn env_shadow_map(e: EnvInfo, centre: [f64; 3], radius: f64, size: u32) -> ShadowMap {
+    // After Effects' environment-light shadows are soft out of the box, and this
+    // map covers the whole scene bounding sphere — not the view — so its texels
+    // can be coarse (all the more in a draft render's flat 512 budget). A
+    // penumbra of at least eight output pixels, or four map texels where those
+    // are coarser, keeps the edge smooth at any map resolution; Shadow Diffusion
+    // widens it further, as for the other lights.
+    let texel = 2.0 * radius / size as f64;
+    let soft = (4.0 * texel).max(8.0) + (e.shadow_diffusion as f64 * 0.5).min(24.0);
+    let sun = e.sun.map(|v| v as f64);
+    let dir = [-sun[0], -sun[1], -sun[2]];
+    let eye = [centre[0] + sun[0] * radius * 2.0, centre[1] + sun[1] * radius * 2.0, centre[2] + sun[2] * radius * 2.0];
+    let hint = if dir[1].abs() < 0.9 { [0.0, 1.0, 0.0] } else { [0.0, 0.0, 1.0] };
+    let focal = (size as f64 * 0.5 / radius) as f32;
+    ShadowMap { view: basis(eye, dir, hint), focal, ortho: true, size, offset: 0, bias: 1.5, radius: soft as f32 }
+}
+
+/// Build the shadow maps of every shadow-casting light (lights marked `shadow == 0`), and of
+/// the Environment light when it casts shadows and its image has a dominant direction (marked
+/// `env.shadow == 0`, `env.sun != [0; 3]`): one map from that direction, like a parallel light.
 pub(crate) fn shadow_maps(s: &mut Scene, draft: bool) {
     let casters: Vec<usize> = (0..s.indices.len() / 3)
         .filter(|&t| s.materials.get(s.vertices[s.indices[3 * t] as usize].material as usize).is_some_and(|m| m.casts_shadows))
         .collect();
+    // The Environment light casts a shadow when marked and its image has a dominant direction;
+    // with nothing to cast one, its mark is cleared either way.
+    let env_shadow = !casters.is_empty() && s.env.is_some_and(|e| e.shadow == 0 && e.sun != [0.0; 3]);
+    if !env_shadow && let Some(e) = &mut s.env {
+        e.shadow = -1;
+    }
     if casters.is_empty() {
         for l in &mut s.lights {
             l.shadow = -1;
@@ -536,6 +564,8 @@ pub(crate) fn shadow_maps(s: &mut Scene, draft: bool) {
                 1
             }
         })
+        // The Environment light's map is a single orthographic one.
+        .chain(std::iter::once(if env_shadow { 1 } else { 0 }))
         .collect();
     let sizes = shadow_sizes(s.width, s.height, draft, &kinds);
     let mut maps: Vec<ShadowMap> = vec![];
@@ -583,6 +613,25 @@ pub(crate) fn shadow_maps(s: &mut Scene, draft: bool) {
         }
         s.lights[li].shadow = first;
     }
+    // The Environment light's shadow: one orthographic map over the scene from its dominant
+    // direction (the light travels from the bright region into the scene), after the lights'.
+    if env_shadow && let Some(e) = s.env {
+        match sizes.get(s.lights.len()).copied().flatten() {
+            Some(size) => {
+                let first = maps.len() as i32;
+                maps.push(env_shadow_map(e, centre, radius, size));
+                if let Some(e) = &mut s.env {
+                    e.shadow = first;
+                }
+            }
+            // The texel budget dropped it.
+            None => {
+                if let Some(e) = &mut s.env {
+                    e.shadow = -1;
+                }
+            }
+        }
+    }
     let texels: Vec<Vec<f32>> = maps.par_iter().map(|m| shadow_raster(s, m, &casters)).collect();
     for (m, t) in maps.iter_mut().zip(texels) {
         m.offset = s.shadow_texels.len() as u32;

crates/render/src/three_d/adv/scene.rs

@@ -172,6 +172,24 @@ pub struct EnvInfo {
     pub intensity: f32,
     /// Radians about the vertical axis.
     pub rotation: f32,
+    /// Unit direction from the scene towards the environment's dominant (radiance-weighted)
+    /// bright region — the direction its shadow is cast from, like a parallel light's
+    /// `to_light`. `[0; 3]` when the image is directionless (uniform, or opposing bright
+    /// regions that cancel) or the light casts no shadow (nothing reads it then): no shadow.
+    pub sun: [f32; 3],
+    /// The image's directional (key) fraction — `|Σ dir·radiance| / Σ radiance` over the
+    /// sphere, 0 for a uniform image and near 1 for a single bright spot. An Environment
+    /// light's shadow occludes only this much of its light: the key lobe is blocked where
+    /// the map says so, the remaining fill keeps shining, so the shadow stays partial the
+    /// way After Effects renders an area-light shadow (a broad environment like the default
+    /// studio shadows softly, a lone bright spot on black almost fully).
+    pub key: f32,
+    /// Shadow map index into [`Scene::shadows`]: 0 marked (assigned by `raster::shadow_maps`),
+    /// -1 casts no shadow. Gated by the light's Cast Shadows.
+    pub shadow: i32,
+    pub shadow_darkness: f32,
+    /// The light's Shadow Diffusion (the penumbra width the shadow map's PCF widens to).
+    pub shadow_diffusion: f32,
 }
 
 #[derive(Clone, Debug, Default)]
@@ -670,9 +688,20 @@ fn card_layer(r: &Renderer, ctx: &EvalCtx, layer: &Layer, b: &mut Builder) {
     }
 }
 
-/// Evaluated lights: (scene lights, ambient sum, environment light (layer, intensity × colour,
-/// rotation)).
-fn lights(ctx: &EvalCtx, lin: bool) -> (Vec<Light>, [f32; 3], Option<(Option<u64>, [f32; 3], f32)>) {
+/// The evaluated Environment light: its image source, intensity × colour, rotation, and
+/// shadow settings (After Effects' Light Settings shows Cast Shadows for Environment lights).
+#[derive(Clone, Copy)]
+pub(crate) struct EnvLight {
+    src: Option<u64>,
+    color: [f32; 3],
+    rot: f32,
+    casts_shadows: bool,
+    shadow_darkness: f64,
+    shadow_diffusion: f64,
+}
+
+/// Evaluated lights: (scene lights, ambient sum, environment light).
+fn lights(ctx: &EvalCtx, lin: bool) -> (Vec<Light>, [f32; 3], Option<EnvLight>) {
     let mut out = vec![];
     let mut ambient = [0.0f32; 3];
     let mut env = None;
@@ -693,7 +722,14 @@ fn lights(ctx: &EvalCtx, lin: bool) -> (Vec<Light>, [f32; 3], Option<(Option<u64
                 if env.is_none() {
                     let src = g.get("source").and_then(|p| ctx.value(layer, p).as_layer());
                     let rot = ctx.f(layer, g, "rotation", 0.0).to_radians() as f32;
-                    env = Some((src, color, rot));
+                    env = Some(EnvLight {
+                        src,
+                        color,
+                        rot,
+                        casts_shadows: ctx.b(layer, g, "castsShadows"),
+                        shadow_darkness: ctx.f(layer, g, "shadowDarkness", 100.0).clamp(0.0, 100.0) / 100.0,
+                        shadow_diffusion: ctx.f(layer, g, "shadowDiffusion", 0.0).max(0.0),
+                    });
                 }
             }
             _ => {
@@ -783,8 +819,54 @@ pub fn irradiance_map(sw: u32, sh: u32, src: &[[f32; 4]], w: u32, h: u32) -> Vec
     out
 }
 
+/// The environment image's dominant direction and key strength: the mean texel direction
+/// weighted by the radiance the light actually emits — solid-angle weighted, rotation applied,
+/// each texel's channels scaled by `tint` (the light's colour, `[1; 3]` for a white one) — or
+/// `([0; 3], 0.0)` when that radiance is directionless (a uniform environment cancels to zero,
+/// and opposing bright regions that cancel leave no mean either — though a chromatic one need
+/// not stay directionless once tinted: a red light over equally bright red and blue opposite
+/// regions removes the blue pull and points at the red one). The mean of a single bright spot
+/// on black points straight at it; a gradient points somewhere between its ends. The returned
+/// key fraction is the mean vector's length over the radiance weight — how directional the
+/// image is, 0 (uniform) to ~1 (a lone spot) — and is the most of its light an Environment
+/// light's shadow can remove.
+pub(crate) fn dominant_direction(w: u32, h: u32, d: &[[f32; 4]], tint: [f32; 3], rot: f32) -> ([f32; 3], f32) {
+    use super::shade::equirect_dir;
+    let (mut x, mut y, mut z) = (0.0f32, 0.0f32, 0.0f32);
+    let mut weight = 0.0f32;
+    for (i, p) in d.iter().enumerate() {
+        let (tx, ty) = ((i % w as usize) as u32, (i / w as usize) as u32);
+        let (u, v) = ((tx as f32 + 0.5) / w as f32, (ty as f32 + 0.5) / h as f32);
+        // Tinted radiance × solid angle (∝ sin θ): the shadow must follow the light the
+        // environment emits, not the raw texels.
+        let lum = (p[0] * tint[0] + p[1] * tint[1] + p[2] * tint[2]) * (v * std::f32::consts::PI).sin();
+        let dir = equirect_dir(u, v, rot);
+        x += dir[0] * lum;
+        y += dir[1] * lum;
+        z += dir[2] * lum;
+        weight += lum.abs();
+    }
+    // Under 1 % directional, the image is uniform to the eye: no dominant region to shadow
+    // from. A non-finite sum (a NaN or infinite texel) is garbage, not a direction: none then.
+    let len = (x * x + y * y + z * z).sqrt();
+    if !weight.is_finite() || !len.is_finite() || weight <= 1e-9 || len < weight * 0.01 {
+        return ([0.0; 3], 0.0);
+    }
+    ([x / len, y / len, z / len], (len / weight).clamp(0.0, 1.0))
+}
+
 /// Prefilter an environment image into the scene's textures.
-pub(crate) fn add_environment(b: &mut Builder, w: u32, h: u32, data: Vec<[f32; 4]>, intensity: [f32; 3], rotation: f32) {
+pub(crate) fn add_environment(b: &mut Builder, env: &EnvLight, w: u32, h: u32, data: Vec<[f32; 4]>) {
+    // Intensity × colour folded into the radiance (one scalar on the GPU): tint the texels.
+    // A white (or off) light leaves them as they are.
+    let k = (env.color[0] + env.color[1] + env.color[2]) / 3.0;
+    let tint = if k > 0.0 && (env.color[0] != env.color[1] || env.color[1] != env.color[2]) { env.color.map(|c| c / k) } else { [1.0, 1.0, 1.0] };
+    // The shadow direction and key strength from the full-resolution image, before the mip
+    // chain averages it — only a shadow-casting light reads them, so only one pays for the
+    // pass — and weighted by the tint, so the shadow follows the radiance the light emits:
+    // opposing chromatic regions that cancel untinted need not cancel once the colour removes
+    // one of them (a red light over equally bright red and blue sides shadows from the red).
+    let (sun, key) = if env.casts_shadows { dominant_direction(w, h, &data, tint, env.rot) } else { ([0.0; 3], 0.0) };
     // Radiance level 0 at most 1024 wide.
     let (mut w, mut h, mut d) = (w, h, data);
     while w > 1024 {
@@ -807,10 +889,7 @@ pub(crate) fn add_environment(b: &mut Builder, w: u32, h: u32, data: Vec<[f32; 4
     let (sw, sh, sd) = small.unwrap_or((w, h, d));
     let irr = irradiance_map(sw, sh, &sd, 32, 16);
     let ii = b.texture_from(32, 16, [0, 1], irr.into_iter()) as u32;
-    // Intensity × colour folded into the radiance (one scalar on the GPU): tint the texels.
-    let k = (intensity[0] + intensity[1] + intensity[2]) / 3.0;
-    if k > 0.0 && (intensity[0] != intensity[1] || intensity[1] != intensity[2]) {
-        let tint = intensity.map(|c| c / k);
+    if tint != [1.0, 1.0, 1.0] {
         for t in first..=ii {
             let ti = b.s.textures[t as usize];
             for p in &mut b.s.texels[ti.offset as usize..(ti.offset + ti.width * ti.height) as usize] {
@@ -820,16 +899,45 @@ pub(crate) fn add_environment(b: &mut Builder, w: u32, h: u32, data: Vec<[f32; 4
             }
         }
     }
-    b.s.env = Some(EnvInfo { radiance: first, mips: levels, irradiance: ii, intensity: k, rotation });
+    b.s.env = Some(EnvInfo {
+        radiance: first,
+        mips: levels,
+        irradiance: ii,
+        intensity: k,
+        rotation: env.rot,
+        sun,
+        key,
+        // Marked; `raster::shadow_maps` assigns the map (a directionless image casts none).
+        shadow: if env.casts_shadows { 0 } else { -1 },
+        shadow_darkness: env.shadow_darkness as f32,
+        shadow_diffusion: env.shadow_diffusion as f32,
+    });
 }
 
-/// The environment layer's pixels as linear straight RGBA.
-fn env_pixels(r: &Renderer, ctx: &EvalCtx, src: Option<u64>, lin: bool) -> Option<(u32, u32, Vec<[f32; 4]>)> {
+/// The Environment light's image: `Absent` when the light has no Source and the comp has no
+/// Environment Layer (the default studio environment applies — After Effects "uses a default
+/// environment map" for an Environment light too), `Image` when the source renders, `Failed`
+/// when a selected or found source produced no pixels (a deleted layer, missing footage, a
+/// failed decode). A failed source must not silently become the default environment — that
+/// would relight and reshadow the scene behind the user's back — so, like any layer whose
+/// source fails renders nothing, it contributes nothing (#2436).
+enum EnvPixels {
+    Absent,
+    Image((u32, u32, Vec<[f32; 4]>)),
+    Failed,
+}
+
+fn env_pixels(r: &Renderer, ctx: &EvalCtx, src: Option<u64>, lin: bool) -> EnvPixels {
     let layer = match src {
-        Some(id) => ctx.comp.layer(effectcraft_project::LayerId(id))?,
-        None => ctx.comp.layers.iter().find(|l| l.environment && l.is_active_at(ctx.time))?,
+        Some(id) => ctx.comp.layer(effectcraft_project::LayerId(id)),
+        None => ctx.comp.layers.iter().find(|l| l.environment && l.is_active_at(ctx.time)),
     };
-    let buf = r.blend_layer_buf(ctx, layer)?;
+    let Some(layer) = layer else {
+        // A set Source that resolves to no layer (deleted) failed; an unset one with no
+        // Environment Layer is simply unconfigured.
+        return if src.is_some() { EnvPixels::Failed } else { EnvPixels::Absent };
+    };
+    let Some(buf) = r.blend_layer_buf(ctx, layer) else { return EnvPixels::Failed };
     let img = &buf.img;
     let data = img
         .data
@@ -843,7 +951,43 @@ fn env_pixels(r: &Renderer, ctx: &EvalCtx, src: Option<u64>, lin: bool) -> Optio
             if lin { [s[0], s[1], s[2], 1.0] } else { [srgb_to_linear(s[0]), srgb_to_linear(s[1]), srgb_to_linear(s[2]), 1.0] }
         })
         .collect();
-    Some((img.width, img.height, data))
+    EnvPixels::Image((img.width, img.height, data))
+}
+
+/// The default environment when the light has no Source and no Environment Layer: a dim studio
+/// gradient, bright above and toward the initial camera, dark below and behind — After
+/// Effects "uses a default environment map" for an Environment light too, and its default
+/// casts shadows out of the box. The solid-angle-weighted mean is 0.3, a soft studio ambience
+/// (a mean of 1 would act like a 100 % white Ambient light and wash the whole scene out, which
+/// is not what After Effects' default looks like); the light's colour × intensity still scales
+/// the overall level, and its Rotation turns the key around the scene (#2436).
+pub(crate) fn default_environment() -> (u32, u32, Vec<[f32; 4]>) {
+    use super::shade::{dot, equirect_dir};
+    // The key region's centre: three quarters up, two thirds toward the viewer (the default
+    // camera looks +z from -z).
+    let key = [0.0f32, -0.75, -0.66];
+    let (w, h) = (8u32, 4u32);
+    let mut data = Vec::with_capacity((w * h) as usize);
+    let (mut mean, mut weight) = (0.0f32, 0.0f32);
+    for y in 0..h {
+        let v = (y as f32 + 0.5) / h as f32;
+        let sa = (v * std::f32::consts::PI).sin();
+        for x in 0..w {
+            let u = (x as f32 + 0.5) / w as f32;
+            let l = 0.15 + 1.2 * dot(equirect_dir(u, v, 0.0), key).max(0.0);
+            data.push([l, l, l, 1.0]);
+            mean += l * sa;
+            weight += sa;
+        }
+    }
+    // A dim studio: scale the gradient to a weighted mean of exactly 0.3.
+    let k = if mean.is_finite() && mean > 1e-6 { 0.3 * weight / mean } else { 1.0 };
+    for p in &mut data {
+        for c in 0..3 {
+            p[c] *= k;
+        }
+    }
+    (w, h, data)
 }
 
 /// Supersampling factor: 2×2 unless draft or very large.
@@ -935,10 +1079,23 @@ pub(crate) fn build_at(r: &Renderer, ctx: &EvalCtx, sub: Option<&EvalCtx>, run:
         let (ls, amb, env) = lights(ctx, lin);
         b.s.lights = ls;
         b.s.ambient = amb;
-        if let Some((src, k, rot)) = env
-            && let Some((w, h, d)) = env_pixels(r, ctx, src, lin)
-        {
-            add_environment(&mut b, w, h, d, k, rot);
+        if let Some(env) = env {
+            match env_pixels(r, ctx, env.src, lin) {
+                EnvPixels::Image((w, h, d)) => add_environment(&mut b, &env, w, h, d),
+                // No Source and no Environment Layer: the default environment, a soft studio
+                // gradient of the light's colour × intensity — After Effects "uses a default
+                // environment map" for an Environment light — so the light always lights the
+                // scene per its parameters, and its dominant region casts shadows (#2436).
+                EnvPixels::Absent => {
+                    let (w, h, d) = default_environment();
+                    add_environment(&mut b, &env, w, h, d)
+                }
+                // A selected or found source that produced no pixels (deleted layer, missing
+                // footage, failed decode): no environment at all — the light contributes
+                // nothing, exactly like a layer whose source failed renders nothing, never a
+                // silent swap to the default studio's lighting and shadows (#2436).
+                EnvPixels::Failed => {}
+            }
         }
         if r.opts.shadows() {
             super::raster::shadow_maps(&mut b.s, r.opts.draft);
@@ -947,6 +1104,9 @@ pub(crate) fn build_at(r: &Renderer, ctx: &EvalCtx, sub: Option<&EvalCtx>, run:
             for l in &mut b.s.lights {
                 l.shadow = -1;
             }
+            if let Some(e) = &mut b.s.env {
+                e.shadow = -1;
+            }
         }
     }
     // Camera matrices.

crates/render/src/three_d/adv/shade.rs

@@ -382,6 +382,23 @@ pub fn light_shadow(s: &Scene, l: &Light, p: [f32; 3], ng: [f32; 3], n_l: f32) -
     1.0 - l.shadow_darkness * (1.0 - f)
 }
 
+/// The visibility of the Environment light at `p` (1 = unshadowed), darkened by its Shadow
+/// Darkness — but only by the image's key fraction: the shadow map occludes the dominant
+/// (key) lobe, while the environment's fill keeps shining on the shadowed surface, so an
+/// Environment light's shadow stays partial the way After Effects renders an area-light
+/// shadow (a broad environment like the default studio shadows softly, a lone bright spot
+/// on black almost fully). A directionless image (or a non-casting light) has no map
+/// and shades unshadowed.
+pub fn env_shadow(s: &Scene, e: &EnvInfo, p: [f32; 3], ng: [f32; 3], n: [f32; 3]) -> f32 {
+    if e.shadow < 0 || e.sun == [0.0; 3] {
+        return 1.0;
+    }
+    let Some(m) = s.shadows.get(e.shadow as usize) else { return 1.0 };
+    let n_l = dot(n, e.sun).clamp(0.0, 1.0);
+    let f = shadow_factor(m, &s.shadow_texels, p, ng, n_l);
+    1.0 - e.shadow_darkness * e.key * (1.0 - f)
+}
+
 /// Unit direction from `p` to light `l`, and the distance (infinite for a parallel light).
 fn to_light(l: &Light, p: [f32; 3]) -> ([f32; 3], f32) {
     if l.kind == 0 {
@@ -529,9 +546,11 @@ pub fn shade(s: &Scene, f: &Frag) -> Option<[f32; 4]> {
         let (irr, spec) = env_light(s, e, n, r, rough);
         let f0 = [mix(0.04 * m.specular_k, rgb[0], metallic), mix(0.04 * m.specular_k, rgb[1], metallic), mix(0.04 * m.specular_k, rgb[2], metallic)];
         let (a, b) = env_brdf(n_v, rough);
+        // The Environment light's shadow darkens its own diffuse and specular.
+        let sh = if m.receives_shadows { env_shadow(s, e, f.pos, ng, n) } else { 1.0 };
         for c in 0..3 {
             let fs = f0[c] * a + b;
-            out[c] += (irr[c] * rgb[c] * (1.0 - fs) * (1.0 - metallic) * m.diffuse_k + spec[c] * fs) * ao;
+            out[c] += (irr[c] * rgb[c] * (1.0 - fs) * (1.0 - metallic) * m.diffuse_k + spec[c] * fs) * ao * sh;
         }
     }
     let c = add(out, emissive);
@@ -557,5 +576,9 @@ fn shadow_only(s: &Scene, m: &Material, f: &Frag, alpha: f32) -> [f32; 4] {
         }
         amount = amount.max(1.0 - light_shadow(s, l, f.pos, n, n_l));
     }
+    // The Environment light's shadow counts too (it reaches every surface: no falloff).
+    if let Some(e) = &s.env {
+        amount = amount.max(1.0 - env_shadow(s, e, f.pos, n, n));
+    }
     [0.0, 0.0, 0.0, alpha * amount]
 }