Merge branch 'worktree-agent-ae879257b39393c25'

# Conflicts:
#	docs/parity.md

crates/engine/src/commands/create.rs

@@ -0,0 +1,139 @@
+//! Layer ▸ Create: Convert to Editable Text (Photoshop type layers), Create Shapes from Text,
+//! Create Masks from Text and Create Shapes from Vector Layer (SVG footage).
+
+use effectcraft_color::Label;
+use effectcraft_project::{ItemKind, LayerSource, Solid};
+use serde_json::{Value, json};
+
+use super::{CommandSpec, bad, has_layers, layers_p, str_p};
+use crate::{EngineError, Result, Session, cmd};
+
+const OPS: &str = "editableText|shapesFromText|masksFromText|shapesFromVector";
+
+fn create(s: &mut Session, p: &Value) -> Result<Value> {
+    let op = str_p(p, "op").ok_or_else(|| bad("layer.create", format!("missing `op` ({OPS})")))?;
+    let (cid, lids) = layers_p(s, p)?;
+    if lids.is_empty() {
+        return Err(bad("layer.create", "select a layer first"));
+    }
+    let time = s.time();
+    let mut created = vec![];
+    let mut skipped = vec![];
+    for lid in lids {
+        let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
+        let Some(src) = comp.layer(lid).cloned() else { continue };
+        let footage = src.source.item().and_then(|i| match &s.project.item(i)?.kind {
+            ItemKind::Footage(f) => Some(f.clone()),
+            _ => None,
+        });
+        match op {
+            "shapesFromVector" => {
+                let Some(f) = footage.filter(|f| f.codec == "SVG" || f.path.to_ascii_lowercase().ends_with(".svg")) else {
+                    skipped.push(format!("{}: not a vector (SVG) footage layer", src.name));
+                    continue;
+                };
+                let bytes = s.services.read_file(&f.path).map_err(|e| EngineError::Other(format!("cannot read {}: {e}", f.path)))?;
+                let doc = effectcraft_svg::parse(&bytes).map_err(|e| EngineError::Other(format!("{}: {e}", f.path)))?;
+                let id = s.edit("Create Shapes from Vector Layer", None, |proj, st| {
+                    let l = crate::vector::shapes_from_vector(proj, &comp, &src, &doc);
+                    let id = l.id;
+                    insert_above(proj, cid, lid, l, true)?;
+                    st.selected_layers = vec![id];
+                    Ok(id)
+                })?;
+                created.push(id.0);
+            }
+            "shapesFromText" => {
+                if !matches!(src.source, LayerSource::Text) {
+                    skipped.push(format!("{}: not a text layer", src.name));
+                    continue;
+                }
+                let snapshot = s.project.clone();
+                let id = s.edit("Create Shapes from Text", None, |proj, st| {
+                    let l = crate::vector::shapes_from_text(proj, &comp, &snapshot, cid, &src, time)
+                        .ok_or_else(|| bad("layer.create", "the text layer has no glyphs"))?;
+                    let id = l.id;
+                    insert_above(proj, cid, lid, l, true)?;
+                    st.selected_layers = vec![id];
+                    Ok(id)
+                })?;
+                created.push(id.0);
+            }
+            "masksFromText" => {
+                if !matches!(src.source, LayerSource::Text) {
+                    skipped.push(format!("{}: not a text layer", src.name));
+                    continue;
+                }
+                let outlines = crate::vector::text_outlines_in_comp(&s.project, cid, &comp, &src, time);
+                if outlines.is_empty() {
+                    skipped.push(format!("{}: no glyphs", src.name));
+                    continue;
+                }
+                let id = s.edit("Create Masks from Text", None, |proj, st| {
+                    let name = comp.unique_layer_name(&format!("{} Outlines", src.name));
+                    let folder = proj.folder_named("Solids").unwrap_or_else(|| proj.add_item("Solids", Label::Yellow, None, ItemKind::Folder));
+                    let sid = proj.add_item(
+                        &name,
+                        Label::Red,
+                        Some(folder),
+                        ItemKind::Solid(Solid { color: [1.0, 1.0, 1.0], width: comp.width, height: comp.height, pixel_aspect: 1.0 }),
+                    );
+                    let mut l = crate::vector::masks_layer(proj, &comp, &name, outlines, sid);
+                    l.in_point = src.in_point;
+                    l.out_point = src.out_point;
+                    let id = l.id;
+                    insert_above(proj, cid, lid, l, true)?;
+                    st.selected_layers = vec![id];
+                    Ok(id)
+                })?;
+                created.push(id.0);
+            }
+            "editableText" => {
+                let Some((f, sl)) = footage.and_then(|f| f.layer.clone().map(|l| (f, l))) else {
+                    skipped.push(format!("{}: not a Photoshop layer", src.name));
+                    continue;
+                };
+                let bytes = s.services.read_file(&f.path).map_err(|e| EngineError::Other(format!("cannot read {}: {e}", f.path)))?;
+                let psd = effectcraft_psd::Psd::parse(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
+                let id = s.edit("Convert to Editable Text", None, |proj, st| {
+                    let l = crate::psd_import::editable_text(proj, &comp, &src, &psd, sl.index as usize)
+                        .ok_or_else(|| bad("layer.create", format!("{}: the Photoshop layer has no text", src.name)))?;
+                    let id = l.id;
+                    let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+                    let at = c.layers.iter().position(|x| x.id == lid).ok_or(EngineError::NoComp)?;
+                    c.layers[at] = l;
+                    st.selected_layers = vec![id];
+                    Ok(id)
+                })?;
+                created.push(id.0);
+            }
+            other => return Err(bad("layer.create", format!("`{other}` is not available yet (supported: {OPS})"))),
+        }
+    }
+    if created.is_empty() && !skipped.is_empty() {
+        return Err(bad("layer.create", skipped.join("; ")));
+    }
+    Ok(json!({"layers": created, "skipped": skipped}))
+}
+
+/// Insert `l` directly above layer `below`; optionally switch the source's video off (as After
+/// Effects does after converting).
+fn insert_above(
+    proj: &mut effectcraft_project::Project,
+    cid: effectcraft_project::ItemId,
+    below: effectcraft_project::LayerId,
+    l: effectcraft_project::Layer,
+    hide_source: bool,
+) -> Result<()> {
+    let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+    let at = c.layers.iter().position(|x| x.id == below).unwrap_or(0);
+    if hide_source && let Some(src) = c.layers.get_mut(at) {
+        src.switches.video = false;
+    }
+    c.layers.insert(at, l);
+    Ok(())
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![cmd!("layer.create", "Create", [], None, "{op: editableText|shapesFromText|masksFromText|shapesFromVector, layers?}", has_layers, create)]
+}

crates/engine/src/commands/edit.rs

@@ -525,12 +525,41 @@ fn purge_caches(s: &mut Session, p: &Value) -> Result<Value> {
         s.snapshot = None;
         s.state.viewer.show_snapshot = false;
     }
+    let memory = matches!(what.as_str(), "all" | "memoryAndDisk" | "memory" | "image");
+    let disk = matches!(what.as_str(), "all" | "memoryAndDisk" | "disk");
+    if memory {
+        s.layer_cache.clear();
+    }
+    let mut disk_entries = 0;
+    if disk && let Some(dc) = &s.disk_cache {
+        disk_entries = dc.stats().entries;
+        dc.clear();
+    }
     if matches!(what.as_str(), "all" | "image" | "memory" | "memoryAndDisk") {
         effectcraft_effects::roto::purge();
     }
     s.events.push(crate::Event::PurgeCaches);
     s.toast(format!("Purged {what} cache"));
-    Ok(json!({"purged": what}))
+    Ok(json!({"purged": what, "diskEntries": disk_entries}))
+}
+
+/// `cache.diskStats`: the disk cache's folder, limit and contents.
+pub(crate) fn disk_stats(s: &mut Session, _: &Value) -> Result<Value> {
+    let Some(dc) = &s.disk_cache else { return Ok(json!({"enabled": false})) };
+    let st = dc.stats();
+    Ok(json!({
+        "enabled": true,
+        "folder": dc.folder().to_string_lossy(),
+        "entries": st.entries,
+        "frames": dc.keys(effectcraft_render::disk_cache::Kind::Frame).len(),
+        "layers": dc.keys(effectcraft_render::disk_cache::Kind::Layer).len(),
+        "bytes": st.bytes,
+        "maxBytes": st.max_bytes,
+        "hits": st.hits,
+        "misses": st.misses,
+        "writes": st.writes,
+        "evictions": st.evictions,
+    }))
 }
 
 /// Path of the footage behind the selected layer or project item.
@@ -599,6 +628,7 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("edit.selectLabelGroup", "Select Label Group", ["Edit", "Label"], None, "{}", has_props_or_layers_or_items, select_label_group),
         cmd!("edit.purgeUndo", "Undo", ["Edit", "Purge"], None, "{}", always_ok, purge),
         cmd!("edit.purge", "Purge", [], None, "{what?: all|memoryAndDisk|memory|disk|3d|image|snapshot}", always_ok, purge_caches),
+        crate::query!("cache.diskStats", "Disk Cache Statistics", "{}", disk_stats),
         cmd!("edit.editOriginal", "Edit Original...", ["Edit"], Some("Cmd+E"), "{}", has_selected_footage, edit_original),
     ]
 }

crates/engine/src/commands/file.rs

@@ -84,10 +84,48 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {
         Some(Value::String(x)) => vec![x.clone()],
         _ => return Err(bad("file.import", "missing `paths`")),
     };
-    let importer = s.importer.clone().ok_or_else(|| EngineError::Other("media import is not available in this build".into()))?;
+    // Photoshop documents as compositions (Import As: Composition / – Retain Layer Sizes).
+    let import_as = str_p(p, "importAs").unwrap_or("footage");
+    let retain = match import_as {
+        "footage" => None,
+        "composition" | "comp" => Some(false),
+        "compositionLayerSizes" | "compositionRetainLayerSizes" | "layerSizes" => Some(true),
+        other => return Err(bad("file.import", format!("importAs: footage|composition|compositionLayerSizes, not `{other}`"))),
+    };
+    let mut paths = paths;
+    let mut out_comps = vec![];
     let mut ids = vec![];
     let mut errors = vec![];
+    if let Some(retain) = retain {
+        let mut rest = vec![];
+        for path in paths {
+            let bytes = match s.services.read_file(&path) {
+                Ok(b) if effectcraft_psd::is_psd(&b) => b,
+                _ => {
+                    rest.push(path);
+                    continue;
+                }
+            };
+            match import_psd_comp(s, &path, bytes, retain) {
+                Ok((comp, items, warnings)) => {
+                    out_comps.push(comp);
+                    ids.extend(items);
+                    errors.extend(warnings);
+                }
+                Err(e) => errors.push(format!("{path}: {e}")),
+            }
+        }
+        paths = rest;
+        if paths.is_empty() {
+            if let Some(c) = out_comps.first() {
+                s.open_comp(effectcraft_project::ItemId(*c));
+            }
+            return Ok(json!({"items": ids, "comps": out_comps, "errors": errors}));
+        }
+    }
+    let importer = s.importer.clone().ok_or_else(|| EngineError::Other("media import is not available in this build".into()))?;
     let mut probed = vec![];
+    let psd_layer = p.get("layer").cloned();
     let seq_rate = effectcraft_time::FrameRate::from_f64(s.prefs.import.sequence_fps);
     for path in &paths {
         match importer.probe(path) {
@@ -99,6 +137,18 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {
                     f.frame_rate = r;
                     f.duration = r.tick_of(frames.max(1));
                 }
+                // Choose Layer: one layer of a Photoshop document (document-sized).
+                if let Some(sel) = &psd_layer
+                    && f.codec == "PSD"
+                {
+                    match s.services.read_file(path).ok().and_then(|b| effectcraft_psd::Psd::parse(b).ok()).and_then(|d| find_psd_layer(&d, sel)) {
+                        Some((index, name)) => f.layer = Some(effectcraft_project::SourceLayer { index: index as u32, name, layer_size: false }),
+                        None => {
+                            errors.push(format!("{path}: no layer {sel}"));
+                            continue;
+                        }
+                    }
+                }
                 probed.push((path.clone(), f))
             }
             Err(e) => errors.push(format!("{path}: {e}")),
@@ -107,6 +157,10 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {
     s.edit("Import", None, |proj, st| {
         for (path, f) in probed {
             let name = std::path::Path::new(&path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or(path.clone());
+            let name = match &f.layer {
+                Some(l) => format!("{}/{name}", l.name),
+                None => name,
+            };
             let label = match f.kind {
                 FootageKind::Still | FootageKind::Sequence => Label::Lavender,
                 FootageKind::Audio => Label::SeaFoam,
@@ -118,7 +172,37 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {
         }
         Ok(())
     })?;
-    Ok(json!({"items": ids, "errors": errors}))
+    if let Some(c) = out_comps.first() {
+        s.open_comp(effectcraft_project::ItemId(*c));
+    }
+    Ok(json!({"items": ids, "comps": out_comps, "errors": errors}))
+}
+
+/// A Photoshop layer by index or name (pixel layers only).
+fn find_psd_layer(d: &effectcraft_psd::Psd, sel: &Value) -> Option<(usize, String)> {
+    let l = match sel {
+        Value::Number(n) => d.layers.get(n.as_u64()? as usize)?,
+        Value::String(name) => d.layers.iter().find(|l| &l.name == name)?,
+        _ => return None,
+    };
+    Some((l.index, l.name.clone()))
+}
+
+/// Import a Photoshop document as a composition (one undo step). Returns (comp, items, warnings).
+fn import_psd_comp(s: &mut Session, path: &str, bytes: Vec<u8>, retain: bool) -> Result<(u64, Vec<u64>, Vec<String>)> {
+    let psd = effectcraft_psd::Psd::parse(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
+    let name = std::path::Path::new(path).file_stem().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "Photoshop".into());
+    let rate = effectcraft_time::FrameRate::FPS_29_97;
+    let secs = if s.prefs.import.still_footage == "seconds" { s.prefs.import.still_seconds } else { 10.0 };
+    let duration = rate.snap_nearest(effectcraft_time::Tick::from_seconds_f64(secs));
+    let r = s.edit("Import", None, |proj, st| {
+        let r = crate::psd_import::import(proj, &psd, path, &name, retain, rate, duration);
+        st.project_selection = vec![r.comp];
+        Ok(r)
+    })?;
+    let mut items = vec![r.folder.0];
+    items.extend(r.items.iter().map(|i| i.0));
+    Ok((r.comp.0, items, r.warnings))
 }
 
 fn project_settings(s: &mut Session, p: &Value) -> Result<Value> {
@@ -224,7 +308,15 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("file.saveAs", "Save As...", ["File", "Save As"], Some("Cmd+Shift+S"), "{path}", always, save_as),
         cmd!("file.incrementAndSave", "Increment and Save", ["File"], Some("Cmd+Alt+Shift+S"), "{}", has_path, increment_save),
         cmd!("file.revert", "Revert", ["File"], None, "{}", has_path, revert),
-        cmd!("file.import", "File...", ["File", "Import"], Some("Cmd+I"), "{paths: [string]}", always, import),
+        cmd!(
+            "file.import",
+            "File...",
+            ["File", "Import"],
+            Some("Cmd+I"),
+            "{paths: [string], importAs?: footage|composition|compositionLayerSizes (Photoshop files), layer?: name|index (footage of one Photoshop layer)}",
+            always,
+            import
+        ),
         cmd!(
             "file.projectSettings",
             "Project Settings...",

crates/engine/src/commands/file_more.rs

@@ -107,6 +107,7 @@ fn placeholder_footage(p: &Value) -> Footage {
         missing: true,
         sequence: vec![],
         color_profile: None,
+        layer: None,
     }
 }
 

crates/engine/src/commands/mod.rs

@@ -6,6 +6,7 @@ pub mod anim_tools;
 mod animation;
 mod comp;
 mod comp_more;
+mod create;
 mod edit;
 mod effect;
 mod file;
@@ -124,6 +125,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
         v.extend(help::specs());
         v.extend(query::specs());
         v.extend(layer_menu::specs());
+        v.extend(create::specs());
         v.extend(animation::specs());
         v.extend(view::specs());
         v.extend(viewer_cmds::specs());

crates/engine/src/commands/render_queue.rs

@@ -131,7 +131,7 @@ fn apply_settings(rs: &mut RenderSettings, p: &Value, cmd: &str) -> Result<bool>
 fn apply_output(om: &mut OutputModule, p: &Value, cmd: &str) -> Result<bool> {
     let mut any = false;
     if let Some(f) = str_p(p, "format") {
-        let f = OutputFormat::from_name(f).ok_or_else(|| bad(cmd, "format: h264|prores|png|jpeg|tiff|exr|gif"))?;
+        let f = OutputFormat::from_name(f).ok_or_else(|| bad(cmd, "format: h264|prores|webm|png|jpeg|tiff|exr|gif|wav|aiff"))?;
         om.set_format(f);
         any = true;
     }
@@ -256,7 +256,7 @@ fn add(s: &mut Session, p: &Value) -> Result<Value> {
     let cid = s.comp_for_queue(p).ok_or(EngineError::NoComp)?;
     let mut it = RenderQueueItem::new(0, cid);
     if let Some(f) = str_p(p, "format") {
-        let f = OutputFormat::from_name(f).ok_or_else(|| bad("renderQueue.add", "format: h264|prores|png|jpeg|tiff|exr|gif"))?;
+        let f = OutputFormat::from_name(f).ok_or_else(|| bad("renderQueue.add", "format: h264|prores|webm|png|jpeg|tiff|exr|gif|wav|aiff"))?;
         it.output = OutputModule::for_format(f);
     }
     apply_settings(&mut it.settings, p, "renderQueue.add")?;
@@ -434,7 +434,7 @@ fn add_output_module(s: &mut Session, p: &Value) -> Result<Value> {
     let n = it.extra_outputs.len() + 2;
     let mut om = it.output.clone();
     if let Some(f) = str_p(p, "format") {
-        let f = OutputFormat::from_name(f).ok_or_else(|| bad("render.addOutputModule", "format: h264|prores|png|jpeg|tiff|exr|gif"))?;
+        let f = OutputFormat::from_name(f).ok_or_else(|| bad("render.addOutputModule", "format: h264|prores|webm|png|jpeg|tiff|exr|gif|wav|aiff"))?;
         om = OutputModule::for_format(f);
     }
     if str_p(p, "output").is_none() && str_p(p, "path").is_none() {
@@ -509,7 +509,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Add to Render Queue",
             ["Composition"],
             Some("Cmd+M"),
-            "{comp?: id|name, format?: h264|prores|png|jpeg|tiff|exr|gif, output?: path|template, quality?: best|draft|1-100 (jpeg), resolution?: full|half|third|quarter|scale, timeSpan?: workArea|comp|custom, start?: s, end?: s, frameRate?: fps|null, motionBlur?: bool, skipExisting?: bool, channels?: rgb|rgba, bitrate?: kbps, proresProfile?: proxy|lt|standard|hq|4444|4444xq, audio?: auto|on|off, sampleRate?, loop?: bool}",
+            "{comp?: id|name, format?: h264|prores|webm|png|jpeg|tiff|exr|gif|wav|aiff, output?: path|template, quality?: best|draft|1-100 (jpeg, webm), resolution?: full|half|third|quarter|scale, timeSpan?: workArea|comp|custom, start?: s, end?: s, frameRate?: fps|null, motionBlur?: bool, skipExisting?: bool, channels?: rgb|rgba, bitrate?: kbps, proresProfile?: proxy|lt|standard|hq|4444|4444xq, audio?: auto|on|off, sampleRate?, loop?: bool}",
             can_add,
             add
         ),

crates/engine/src/commands/stubs.rs

@@ -29,7 +29,6 @@ pub fn specs() -> Vec<CommandSpec> {
         // Mask options not in the mask model yet; pen / vertex editing (timeline milestone).
         // Time (timeline milestone).
         stub!("layer.alignVideoToData", "Align Video to Data", ["Layer", "Time"], "{}"),
-        stub!("layer.create", "Create", [], "{op}"),
         stub!("layer.autoTrace", "Auto-trace...", ["Layer"], "{}"),
         stub!("layer.sceneEditDetection", "Scene Edit Detection...", ["Layer"], "{}"),
         // Cameras / lights / materials / 3D views (3D milestone).