Skip to content

AI media harness for planning, generating, and editing locally

TypeScript

Support Single Shot keystone continuation

Bitti9eb99f39264c
diff --git a/src-tauri/core/src/slopfab/continuation.rs b/src-tauri/core/src/slopfab/continuation.rs
index c69ebc0..f6596b8 100644
--- a/src-tauri/core/src/slopfab/continuation.rs
+++ b/src-tauri/core/src/slopfab/continuation.rs
@@ -311,6 +311,32 @@ pub(super) mod tests {
assert_eq!(wire["latentBridge"]["rightMarginFrames"], 34);
}
+ #[test]
+ fn single_shot_keystone_resolves_one_pass_and_requires_more_than_four_video_updates() {
+ use super::super::types::SingleShotRequest;
+ let source = archive(124).into_temp_path();
+ let context = archive(56).into_temp_path();
+ let source_bytes = std::fs::read(&source).unwrap();
+ let context_bytes = std::fs::read(&context).unwrap();
+ let mut request = GenerationRequest { prompt: "Walk forward".into(), frames: 48, steps: 9, seed: 1,
+ canvas_width: 64, canvas_height: 32,
+ single_shot: Some(SingleShotRequest { ending_prompt: String::new(), ending_path: None }),
+ continuation_path: Some(source.to_path_buf()), continuation_overlap_frames: Some(22),
+ continuation_from: Some("end".into()), continuation_lock_overlap: true,
+ keystone_path: Some(context.to_path_buf()), ..Default::default() };
+ let settings = BTreeMap::new();
+ let plan = resolve_plan(&request, &settings, &ReferenceVideos::default()).unwrap();
+ assert_eq!(plan.aligned_frames, 175);
+ assert_eq!(plan.model_evaluations, 8);
+ assert_eq!(std::fs::read(&source).unwrap(), source_bytes);
+ assert_eq!(std::fs::read(&context).unwrap(), context_bytes);
+ request.steps = 4;
+ assert!(resolve_plan(&request, &settings, &ReferenceVideos::default()).is_err());
+ request.steps = 9;
+ request.continuation_path = None;
+ assert!(resolve_plan(&request, &settings, &ReferenceVideos::default()).unwrap_err().contains("Previous video"));
+ }
+
#[test]
fn single_shot_anchor_plan_matches_preview_with_and_without_a_starting_source() {
use super::super::{ffi::{Api, RequestHandle}, h3::configure_request, config::Configuration,
diff --git a/src-tauri/core/src/slopfab/ffi/mod.rs b/src-tauri/core/src/slopfab/ffi/mod.rs
index 3ff661e..a82b541 100644
--- a/src-tauri/core/src/slopfab/ffi/mod.rs
+++ b/src-tauri/core/src/slopfab/ffi/mod.rs
@@ -165,6 +165,10 @@ impl Api {
self.inner.set_latent_bridge_files(r.pointer.as_ptr(), left, right, left_margin, right_margin, context)
}
pub fn require_end_anchor(&self) -> Result<(), String> { self.inner.require_end_anchor() }
+ pub fn set_keystone_file(&self, r: &RequestHandle, path: &Path) -> Result<(), String> {
+ self.check(r)?;
+ self.inner.set_keystone_file(r.pointer.as_ptr(), path)
+ }
pub fn require_continuation_source_init(&self) -> Result<(), String> { self.inner.require_continuation_source_init() }
pub fn set_continuation_source_init(&self, r: &RequestHandle, noise: f32) -> Result<(), String> {
self.check(r)?;
diff --git a/src-tauri/core/src/slopfab/ffi/raw/mod.rs b/src-tauri/core/src/slopfab/ffi/raw/mod.rs
index fb43bed..e978d3f 100644
--- a/src-tauri/core/src/slopfab/ffi/raw/mod.rs
+++ b/src-tauri/core/src/slopfab/ffi/raw/mod.rs
@@ -123,6 +123,7 @@ pub struct Api {
set_save_latents: Option<unsafe extern "C" fn(*mut Request, *const c_char) -> i32>,
set_continuation_file: Option<unsafe extern "C" fn(*mut Request, *const c_char, i32) -> i32>,
set_end_anchor_file: Option<unsafe extern "C" fn(*mut Request, *const c_char, i32) -> i32>,
+ set_keystone_file: Option<unsafe extern "C" fn(*mut Request, *const c_char, i32, i32) -> i32>,
set_continuation_source_init: Option<unsafe extern "C" fn(*mut Request, i32, f32) -> i32>,
set_latent_bridge_files: Option<unsafe extern "C" fn(*mut Request, *const c_char, *const c_char, i32, i32, i32) -> i32>,
set_continuation_lock_overlap: Option<unsafe extern "C" fn(*mut Request, i32) -> i32>,
@@ -305,6 +306,7 @@ impl Api {
.ok()
.map(|symbol| *symbol),
set_end_anchor_file: library.get::<unsafe extern "C" fn(*mut Request, *const c_char, i32) -> i32>(b"slopfab_request_set_end_anchor_file\0").ok().map(|symbol| *symbol),
+ set_keystone_file: library.get::<unsafe extern "C" fn(*mut Request, *const c_char, i32, i32) -> i32>(b"slopfab_request_set_keystone_file\0").ok().map(|symbol| *symbol),
set_continuation_source_init: library.get::<unsafe extern "C" fn(*mut Request, i32, f32) -> i32>(b"slopfab_request_set_continuation_source_init\0").ok().map(|symbol| *symbol),
set_continuation_lock_overlap: library
.get::<unsafe extern "C" fn(*mut Request, i32) -> i32>(b"slopfab_request_set_continuation_lock_overlap\0")
@@ -566,6 +568,11 @@ impl Api {
pub fn require_end_anchor(&self) -> Result<(), String> {
self.set_end_anchor_file.map(|_| ()).ok_or("Single Shot requires SlopFab API 1.40 or newer. Update the app and workers.".into())
}
+ pub fn set_keystone_file(&self, r: *mut Request, path: &Path) -> Result<(), String> {
+ let set = self.set_keystone_file.ok_or("Context video requires SlopFab API 1.45 or newer. Update the app and workers.")?;
+ let path = CString::new(path.to_string_lossy().as_bytes()).map_err(|_| "Context video path contains a null byte.")?;
+ self.error(unsafe { set(r, path.as_ptr(), 1, 4) })
+ }
pub fn require_continuation_source_init(&self) -> Result<(), String> {
self.set_continuation_source_init.map(|_| ()).ok_or("Single Shot continuation requires SlopFab API 1.41 or newer. Update the app and workers.".into())
}
diff --git a/src-tauri/core/src/slopfab/generation.rs b/src-tauri/core/src/slopfab/generation.rs
index 5128cd7..190bfb0 100644
--- a/src-tauri/core/src/slopfab/generation.rs
+++ b/src-tauri/core/src/slopfab/generation.rs
@@ -28,7 +28,7 @@ pub(super) fn run_generation(
) -> Result<(OutputMetadata, rendered::RenderedVideo), String> {
if item.request.latent_upscale_source.is_some() { return run_latent_upscale(item); }
if item.request.single_shot.is_some() {
- ffi::Api::load(&item.configuration.dll_path)?.require_end_anchor()?;
+ if item.request.keystone_path.is_none() { ffi::Api::load(&item.configuration.dll_path)?.require_end_anchor()?; }
return run_single_shot(item, run_single_generation);
}
run_edit_sequence(item, run_single_generation)
@@ -40,6 +40,9 @@ fn run_single_shot(
) -> Result<(OutputMetadata, rendered::RenderedVideo), String> {
let single = item.request.single_shot.as_ref().ok_or("Missing Single Shot settings.")?;
if item.cancel.load(Ordering::Acquire) { return Err("Single Shot generation cancelled.".into()); }
+ // Keystone supplies both original-clip anchors in a single continuation pass.
+ // A separately generated ending is incompatible with those anchors.
+ if item.request.keystone_path.is_some() { return generate(item); }
let temporary = tempfile::tempdir().map_err(|error| format!("Could not prepare ending latents: {error}"))?;
let ending_path = temporary.path().join("ending.safetensors");
// Condition the ending on the same source as the full shot. An independent
diff --git a/src-tauri/core/src/slopfab/generation_tests.rs b/src-tauri/core/src/slopfab/generation_tests.rs
index fa170fc..22cf945 100644
--- a/src-tauri/core/src/slopfab/generation_tests.rs
+++ b/src-tauri/core/src/slopfab/generation_tests.rs
@@ -131,6 +131,26 @@ fn single_shot_item() -> (QueueItem, tempfile::TempPath) {
(item, source)
}
+#[test]
+fn single_shot_with_context_runs_one_pass_without_an_ending_anchor() {
+ let (mut item, _source) = single_shot_item();
+ let context = super::super::continuation::tests::archive(56).into_temp_path();
+ item.request.keystone_path = Some(context.to_path_buf());
+ item.request.single_shot.as_mut().unwrap().ending_prompt.clear();
+ let mut calls = 0;
+ let (metadata, _) = run_single_shot(&item, |stage| {
+ calls += 1;
+ assert_eq!(stage.request.keystone_path, item.request.keystone_path);
+ assert_eq!(stage.request.continuation_path, item.request.continuation_path);
+ assert_eq!(stage.request.save_latents_path, item.request.save_latents_path);
+ assert_eq!(stage.request.frames, 48);
+ assert!(stage.request.single_shot.as_ref().unwrap().ending_path.is_none());
+ Ok(result(1))
+ }).unwrap();
+ assert_eq!(calls, 1);
+ assert_eq!(metadata.seconds_total, 1.0);
+}
+
#[test]
fn single_shot_generates_ending_first_then_attaches_it_with_the_starting_source() {
for (continued, noise) in [(false, None), (true, None), (true, Some(0.35)), (true, Some(1.0))] {
diff --git a/src-tauri/core/src/slopfab/h3.rs b/src-tauri/core/src/slopfab/h3.rs
index faa3fe6..949c43e 100644
--- a/src-tauri/core/src/slopfab/h3.rs
+++ b/src-tauri/core/src/slopfab/h3.rs
@@ -19,7 +19,7 @@ pub(super) fn configure_request(
) -> Result<(), String> {
if request.music.is_some() { return super::music::configure(api, handle, request, configuration, platform); }
configuration.validate_inputs(request)?;
- if request.single_shot.is_some() { api.require_end_anchor()?; }
+ if request.single_shot.is_some() && request.keystone_path.is_none() { api.require_end_anchor()?; }
let source_noise = super::continuation::source_noise(request);
if source_noise.is_some() { api.require_continuation_source_init()?; }
if crate::models::generator_features(&configuration.model_type).cuda_only {
@@ -163,6 +163,9 @@ pub(super) fn configure_request(
)?;
api.set_continuation_lock_overlap(handle, lock_overlap)?;
}
+ if let Some(path) = &request.keystone_path {
+ api.set_keystone_file(handle, path)?;
+ }
if let Some(path) = request.single_shot.as_ref().and_then(|single| single.ending_path.as_ref()) {
api.set_end_anchor_file(handle, path)?;
}
diff --git a/src-tauri/core/src/slopfab/planning.rs b/src-tauri/core/src/slopfab/planning.rs
index e2b7f38..f65b2ab 100644
--- a/src-tauri/core/src/slopfab/planning.rs
+++ b/src-tauri/core/src/slopfab/planning.rs
@@ -51,7 +51,7 @@ pub fn resolve_plan(
canvas_height: if request.latent_upscale { request.canvas_height } else { plan.canvas_height },
aligned_frames: frames,
duration_seconds: if request.music.is_some() { plan.duration_seconds } else { plan.duration_seconds * frames as f64 / plan.aligned_frames as f64 },
- model_evaluations: plan.num_model_evaluations * if request.single_shot.is_some() { 2 } else { request.image_edit.as_ref().map_or(1, |edit| edit.edits.len() as i32) },
+ model_evaluations: plan.num_model_evaluations * if request.single_shot.is_some() && request.keystone_path.is_none() { 2 } else { request.image_edit.as_ref().map_or(1, |edit| edit.edits.len() as i32) },
sequence_rows_without_text: plan.sequence_rows_without_text,
latent_frames: plan.latent_frames,
latent_width: plan.latent_width,
@@ -72,12 +72,18 @@ pub(super) fn validate_generation_controls(request: &GenerationRequest) -> Resul
}
return Ok(());
}
+ if request.keystone_path.is_some() || request.keystone_relative_path.is_some() {
+ if request.keystone_path.is_none() || request.continuation_path.is_none() || request.single_shot.is_none()
+ || request.single_shot.as_ref().is_some_and(|single| single.ending_path.is_some()) {
+ return Err("Context video requires Single Shot, saved context latents and a Previous video, without a separate ending anchor.".into());
+ }
+ }
if let Some(single) = &request.single_shot {
if request.music.is_some() || request.still_image || request.image_edit.is_some() || request.video_transition.is_some() || request.latent_bridge.is_some()
- || request.frames < 48 || single.ending_prompt.trim().is_empty() || single.ending_prompt.contains('\0') || single.ending_prompt.len() > 1024 * 1024
+ || request.frames < 48 || (request.keystone_path.is_none() && single.ending_prompt.trim().is_empty()) || single.ending_prompt.contains('\0') || single.ending_prompt.len() > 1024 * 1024
|| request.continuation_from.as_deref().is_some_and(|from| from != "end")
|| request.continuation_overlap_frames.is_some_and(|frames| frames != 22) {
- return Err("Single Shot requires a video of at least 2 seconds, an ending prompt and optional ending latents from a starting scene.".into());
+ return Err("Single Shot requires a video of at least 2 seconds, an ending prompt or Context video, and optional ending latents from a Previous video.".into());
}
}
if let Some(music) = &request.music { return music.validate(); }
diff --git a/src-tauri/core/src/slopfab/types.rs b/src-tauri/core/src/slopfab/types.rs
index 17d5ce1..c4dec89 100644
--- a/src-tauri/core/src/slopfab/types.rs
+++ b/src-tauri/core/src/slopfab/types.rs
@@ -103,6 +103,10 @@ pub struct GenerationRequest {
pub refmods: Vec<RefmodInput>,
#[serde(default)]
pub continuation_relative_path: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub keystone_relative_path: Option<String>,
+ #[serde(skip)]
+ pub keystone_path: Option<PathBuf>,
#[serde(default)]
pub continuation_overlap_frames: Option<i32>,
#[serde(default)]
diff --git a/src-tauri/core/src/worker/protocol.rs b/src-tauri/core/src/worker/protocol.rs
index d13c3fa..ffd5ded 100644
--- a/src-tauri/core/src/worker/protocol.rs
+++ b/src-tauri/core/src/worker/protocol.rs
@@ -26,7 +26,8 @@ pub const SERVICE_TYPE: &str = "_slopus-worker._tcp.local.";
// v19 carries Single Shot ending-first generation; older workers would ignore it.
// v20 carries source-initialized continuation; older workers would ignore it.
// v21 keeps Single Shot's middle fresh; v20 workers default to a repeated source prior.
-pub const PROTOCOL_VERSION: u32 = 22;
+// v23 carries Single Shot's persistent context archive; older workers ignore Keystone.
+pub const PROTOCOL_VERSION: u32 = 23;
/// Streaming SeedVR2 restoration; model paths are resolved on the worker.
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -104,6 +105,8 @@ pub struct RemoteJob {
pub settings: BTreeMap<String, ProviderSetting>,
pub files: Vec<FileRef>,
pub continuation: Option<usize>,
+ #[serde(default)]
+ pub keystone: Option<usize>,
pub bridge_left: Option<usize>,
pub bridge_right: Option<usize>,
pub image_edit_source: Option<usize>,
@@ -379,7 +382,7 @@ mod tests {
let single = restored.single_shot.unwrap();
assert_eq!(single.ending_prompt, "The subject waves goodbye");
assert!(single.ending_path.is_none());
- assert_eq!(PROTOCOL_VERSION, 22);
+ assert_eq!(PROTOCOL_VERSION, 23);
}
#[test]
diff --git a/src-tauri/core/src/worker/server.rs b/src-tauri/core/src/worker/server.rs
index b2fdb22..1742997 100644
--- a/src-tauri/core/src/worker/server.rs
+++ b/src-tauri/core/src/worker/server.rs
@@ -646,6 +646,7 @@ impl Worker {
}
let file = |index: Option<usize>| index.map(|index| paths.get(index).cloned().ok_or("A worker job names a file it did not send.")).transpose();
request.continuation_path = file(job.continuation)?;
+ request.keystone_path = file(job.keystone)?;
request.bridge_left_path = file(job.bridge_left)?;
request.bridge_right_path = file(job.bridge_right)?;
if request.latent_bridge.is_some() && (request.bridge_left_path.is_none() || request.bridge_right_path.is_none()) {
diff --git a/src-tauri/src/media/artifacts.rs b/src-tauri/src/media/artifacts.rs
index 49fa5f4..0977b3d 100644
--- a/src-tauri/src/media/artifacts.rs
+++ b/src-tauri/src/media/artifacts.rs
@@ -57,6 +57,7 @@ pub(crate) fn prepare_continuation_path(
folder_path: Option<&str>,
) -> Result<(), String> {
request.continuation_path = None;
+ request.keystone_path = None;
request.bridge_left_path = None;
request.bridge_right_path = None;
if let Some(source) = &mut request.latent_upscale_source {
@@ -75,6 +76,12 @@ pub(crate) fn prepare_continuation_path(
request.bridge_left_path = Some(resolve(&bridge.left_relative_path)?);
request.bridge_right_path = Some(resolve(&bridge.right_relative_path)?);
}
+ if let Some(relative) = &request.keystone_relative_path {
+ let root = ProjectRoot::open(folder_path.ok_or("A project folder is required for Context video.")?)?;
+ let path = root.existing(relative)?;
+ if !path.is_file() { return Err("Context video latents must be a file inside this project.".into()); }
+ request.keystone_path = Some(path);
+ }
if let Some(relative) = &request.continuation_relative_path {
let root = ProjectRoot::open(
folder_path.ok_or("A project folder is required to continue a scene.")?,
diff --git a/src-tauri/src/project/scenes.rs b/src-tauri/src/project/scenes.rs
index 0c2de7f..b7f64fc 100644
--- a/src-tauri/src/project/scenes.rs
+++ b/src-tauri/src/project/scenes.rs
@@ -97,6 +97,8 @@ pub(crate) struct GenerationJob {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) continuation_scene_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
+ pub(crate) context_scene_id: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) continuation_overlap_frames: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) continuation_from: Option<String>,
@@ -178,6 +180,7 @@ impl GenerationJob {
id: id.to_string(),
scene_type: None,
ending_prompt: None,
+ context_scene_id: None,
backdrop_color: None,
bridge_left_margin: None,
bridge_right_margin: None,
diff --git a/src-tauri/src/project/validation/scenes.rs b/src-tauri/src/project/validation/scenes.rs
index ab56ad6..dcad665 100644
--- a/src-tauri/src/project/validation/scenes.rs
+++ b/src-tauri/src/project/validation/scenes.rs
@@ -24,6 +24,7 @@ fn validate_jobs(jobs: &mut [GenerationJob]) -> Result<(), String> {
return Err(format!("Scene '{}' has an ending prompt longer than 30000 characters.", job.id));
}
if job.continuation_scene_id.as_deref() == Some("")
+ || job.context_scene_id.as_deref() == Some("")
|| job.continuation_strength.is_some_and(|strength| !strength.is_finite() || !(0.0..=0.99).contains(&strength))
|| job.continuation_from.as_deref().is_some_and(|value| !matches!(value, "start" | "end"))
|| job.continuation_overlap_frames.is_some_and(|frames| !(22..=362).contains(&frames) || frames % 17 != 5) {
@@ -284,6 +285,7 @@ mod history_tests {
let mut config: ProjectConfig = serde_json::from_str(include_str!("../../../../fixtures/project-v1-complete.json")).unwrap();
config.generation_jobs[0].scene_type = Some("single-shot".into());
config.generation_jobs[0].ending_prompt = Some("@[ref:hero] waves goodbye".into());
+ config.generation_jobs[0].context_scene_id = Some("original".into());
config.generation_jobs[0].continuation_scene_id = Some("start".into());
config.generation_jobs[0].continuation_strength = Some(0.65);
validate(&mut config).unwrap();
@@ -291,6 +293,7 @@ mod history_tests {
assert_eq!(restored.generation_jobs[0].ending_prompt, config.generation_jobs[0].ending_prompt);
assert_eq!(restored.generation_jobs[0].scene_type.as_deref(), Some("single-shot"));
assert_eq!(restored.generation_jobs[0].continuation_scene_id.as_deref(), Some("start"));
+ assert_eq!(restored.generation_jobs[0].context_scene_id.as_deref(), Some("original"));
assert_eq!(restored.generation_jobs[0].continuation_strength, Some(0.65));
config.generation_jobs[0].continuation_strength = Some(1.0);
assert!(validate(&mut config).is_err());
diff --git a/src-tauri/src/tests/artifacts.rs b/src-tauri/src/tests/artifacts.rs
index 4a93a21..20c33b0 100644
--- a/src-tauri/src/tests/artifacts.rs
+++ b/src-tauri/src/tests/artifacts.rs
@@ -36,6 +36,28 @@ fn a_rendered_scene_lands_in_the_project_under_its_own_id() {
assert!(destination.starts_with(folder.path().canonicalize().unwrap()));
}
+#[test]
+fn context_latents_are_resolved_inside_the_project_and_not_accepted_as_host_paths() {
+ let folder = project_folder();
+ let root = folder.path().to_string_lossy();
+ let destination = generated_latent_destination(&root, "context").unwrap();
+ fs::write(&destination, b"archive").unwrap();
+ let mut request: slopfab::GenerationRequest = serde_json::from_value(serde_json::json!({
+ "jobId": "next", "prompt": "Continue", "frames": 119, "steps": 9, "seed": 1,
+ "canvasWidth": 736, "canvasHeight": 416,
+ "keystoneRelativePath": "latents/context.safetensors", "keystonePath": "C:/outside.safetensors"
+ })).unwrap();
+ assert!(request.keystone_path.is_none());
+ assert!(prepare_continuation_path(&mut request, None).is_err());
+ prepare_continuation_path(&mut request, Some(&root)).unwrap();
+ assert_eq!(request.keystone_path.as_ref(), Some(&destination));
+ for invalid in ["../outside.safetensors", "C:/outside.safetensors", "latents/missing.safetensors", "latents"] {
+ request.keystone_relative_path = Some(invalid.into());
+ assert!(prepare_continuation_path(&mut request, Some(&root)).is_err());
+ assert!(request.keystone_path.is_none());
+ }
+}
+
#[test]
fn latent_archives_are_unique_and_confined_to_the_project() {
let folder = project_folder();
diff --git a/src-tauri/src/worker/client.rs b/src-tauri/src/worker/client.rs
index af8ef6d..78bd5ff 100644
--- a/src-tauri/src/worker/client.rs
+++ b/src-tauri/src/worker/client.rs
@@ -279,7 +279,7 @@ impl Workers {
if stop.load(Ordering::Acquire) { return Err("Export cancelled.".into()); }
if !uploads.is_empty() {
let job = RemoteJob { request: GenerationRequest { job_id: id.into(), ..Default::default() },
- settings: BTreeMap::new(), files: uploads, continuation: None, image_edit_source: None, bridge_left: None, bridge_right: None };
+ settings: BTreeMap::new(), files: uploads, continuation: None, keystone: None, image_edit_source: None, bridge_left: None, bridge_right: None };
let cancel = Arc::new(AtomicBool::new(false));
let finished = AtomicBool::new(false);
std::thread::scope(|scope| {
@@ -968,6 +968,8 @@ pub(crate) fn build_job(request: &GenerationRequest, settings: &BTreeMap<String,
})?;
let continuation = request.continuation_path.take()
.map(|path| add(PathKind::Input, &path.to_string_lossy(), &mut files)).transpose()?;
+ let keystone = request.keystone_path.take()
+ .map(|path| add(PathKind::Input, &path.to_string_lossy(), &mut files)).transpose()?;
let image_edit_source = request.image_edit_path.take()
.map(|path| add(PathKind::Input, &path.to_string_lossy(), &mut files)).transpose()?;
request.save_latents_path = None;
@@ -976,7 +978,7 @@ pub(crate) fn build_job(request: &GenerationRequest, settings: &BTreeMap<String,
.map(|path| add(PathKind::Input, &path.to_string_lossy(), &mut files)).transpose()?;
let bridge_right = request.bridge_right_path.take()
.map(|path| add(PathKind::Input, &path.to_string_lossy(), &mut files)).transpose()?;
- Ok((RemoteJob { request, settings, files, continuation, image_edit_source, bridge_left, bridge_right }, sources))
+ Ok((RemoteJob { request, settings, files, continuation, keystone, image_edit_source, bridge_left, bridge_right }, sources))
}
#[cfg(test)]
@@ -1146,6 +1148,7 @@ mod tests {
job_id: "work-1".into(),
reference_paths: vec![image.to_string_lossy().into_owned(), image.to_string_lossy().into_owned()],
continuation_path: Some(image.clone()),
+ keystone_path: Some(image.clone()),
continuation_from: Some("start".into()),
continuation_overlap_frames: Some(39),
continuation_source_frames: Some(85),
@@ -1164,7 +1167,10 @@ mod tests {
assert_eq!(entries.iter().map(|entry| entry.path.as_str()).collect::<Vec<_>>(), vec!["nested/merges.txt", "vocab.json"]);
assert_eq!(job.request.reference_paths, vec![file_token(2), file_token(2)]);
assert_eq!(job.continuation, Some(2));
+ assert_eq!(job.keystone, Some(2));
let wire = serde_json::to_value(&job).unwrap();
+ assert!(wire["request"].get("keystonePath").is_none());
+ assert_eq!(wire["keystone"], 2);
assert_eq!(wire["request"]["continuationFrom"], "start");
assert_eq!(wire["request"]["continuationOverlapFrames"], 39);
assert_eq!(wire["request"]["continuationSourceFrames"], 85);