Skip to content

AI media harness for planning, generating, and editing locally

TypeScript

Rename engine to SlopFab

Bittiefbfe0e2c0f6
diff --git a/src-tauri/src/agent.rs b/src-tauri/src/agent.rs
index 750f98d..fa1ea28 100644
--- a/src-tauri/src/agent.rs
+++ b/src-tauri/src/agent.rs
@@ -2363,7 +2363,7 @@ mod tests {
// a change that cannot affect its answer.
let mut with_engine = BTreeMap::new();
with_engine.insert(
- "vidfab".to_string(),
+ "slopfab".to_string(),
ProviderSetting {
enabled: true,
model: None,
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index a89bdb8..cc29b7e 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -13,9 +13,9 @@ mod agent_commands;
mod diagnostics;
mod export;
mod rendered;
-mod vidfab;
+mod slopfab;
-pub use vidfab::{generate_reference_icon_batch, ReferenceIconBatchConfig, ReferenceIconSpec};
+pub use slopfab::{generate_reference_icon_batch, ReferenceIconBatchConfig, ReferenceIconSpec};
const PROJECT_FILE_NAME: &str = "polstudio.json";
/// What the file was called before, newest first. Folders written by earlier
@@ -2132,18 +2132,18 @@ fn save_project(folder_path: String, config: ProjectConfig) -> Result<(), String
#[serde(rename_all = "camelCase")]
struct RuntimeStatus {
providers: Vec<agent::ProviderStatus>,
- vidfab: vidfab::VidfabStatus,
+ slopfab: slopfab::SlopfabStatus,
}
/// Probes the video engine from provider settings alone. The settings screen
/// has no project in hand — engine paths belong to the machine, not to a
/// project file — so it cannot go through `runtime_status`.
#[tauri::command]
-fn vidfab_status(settings: BTreeMap<String, ProviderSetting>) -> vidfab::VidfabStatus {
- let status = vidfab::status(&settings);
+fn slopfab_status(settings: BTreeMap<String, ProviderSetting>) -> slopfab::SlopfabStatus {
+ let status = slopfab::status(&settings);
diagnostics::info(
"runtime",
- "vidfab.probed",
+ "slopfab.probed",
"Video engine probe completed.",
serde_json::json!({
"state": status.state,
@@ -2201,7 +2201,7 @@ async fn runtime_status(
) -> Result<RuntimeStatus, String> {
let result = tauri::async_runtime::spawn_blocking(move || RuntimeStatus {
providers: agent::provider_statuses(&settings),
- vidfab: vidfab::status(&settings),
+ slopfab: slopfab::status(&settings),
})
.await
.map_err(|error| format!("Could not probe this computer: {error}"));
@@ -2211,9 +2211,9 @@ async fn runtime_status(
"application.probed",
"Application runtime probe completed.",
serde_json::json!({
- "vidfabState": status.vidfab.state,
- "vidfabVersion": status.vidfab.version,
- "platform": status.vidfab.platform,
+ "slopfabState": status.slopfab.state,
+ "slopfabVersion": status.slopfab.version,
+ "platform": status.slopfab.platform,
"providers": status.providers.iter().map(|provider| serde_json::json!({
"id": provider.id, "state": provider.state, "version": provider.version,
})).collect::<Vec<_>>(),
@@ -2275,26 +2275,26 @@ fn cancel_agent_turn(state: tauri::State<'_, agent::AgentRuntime>, request_id: S
}
#[tauri::command]
-fn resolve_vidfab_plan(
- request: vidfab::GenerationRequest,
+fn resolve_slopfab_plan(
+ request: slopfab::GenerationRequest,
config: ProjectConfig,
-) -> Result<vidfab::ResolvedPlan, String> {
+) -> Result<slopfab::ResolvedPlan, String> {
let context = serde_json::json!({
"jobId": request.job_id, "frames": request.frames, "steps": request.steps,
"canvasWidth": request.canvas_width, "canvasHeight": request.canvas_height,
"referenceCount": request.reference_paths.len(), "inputChars": request.prompt.chars().count(),
});
diagnostics::info(
- "vidfab",
+ "slopfab",
"plan.requested",
"Generation plan requested.",
context.clone(),
);
let result = validate_and_normalize_config(config)
- .and_then(|config| vidfab::resolve_plan(&request, &config.provider_settings));
+ .and_then(|config| slopfab::resolve_plan(&request, &config.provider_settings));
match &result {
Ok(plan) => diagnostics::info(
- "vidfab",
+ "slopfab",
"plan.resolved",
"Generation plan resolved.",
serde_json::json!({
@@ -2303,16 +2303,16 @@ fn resolve_vidfab_plan(
"durationSeconds": plan.duration_seconds, "modelEvaluations": plan.model_evaluations,
}),
),
- Err(error) => diagnostics::error("vidfab", "plan.failed", error, context),
+ Err(error) => diagnostics::error("slopfab", "plan.failed", error, context),
}
result
}
#[tauri::command]
-fn enqueue_vidfab_generation(
+fn enqueue_slopfab_generation(
app: AppHandle,
- state: tauri::State<'_, vidfab::VidfabRuntime>,
- request: vidfab::GenerationRequest,
+ state: tauri::State<'_, slopfab::SlopfabRuntime>,
+ request: slopfab::GenerationRequest,
config: ProjectConfig,
) -> Result<(), String> {
let job_id = request.job_id.clone();
@@ -2320,7 +2320,7 @@ fn enqueue_vidfab_generation(
.and_then(|config| state.enqueue(app, request, &config.provider_settings));
if let Err(error) = &result {
diagnostics::error(
- "vidfab",
+ "slopfab",
"generation.enqueue_failed",
error,
serde_json::json!({ "jobId": job_id }),
@@ -2330,15 +2330,15 @@ fn enqueue_vidfab_generation(
}
#[tauri::command]
-fn cancel_vidfab_generation(
- state: tauri::State<'_, vidfab::VidfabRuntime>,
+fn cancel_slopfab_generation(
+ state: tauri::State<'_, slopfab::SlopfabRuntime>,
job_id: String,
) -> bool {
state.cancel(&job_id)
}
/* ── A finished render, on its way to a file ─────────────────────────────────
-vidfab produces pictures, not files. The webview turns them into an MP4 —
+slopfab produces pictures, not files. The webview turns them into an MP4 —
WebCodecs owns the hardware encoder and there is no FFmpeg here (CLAUDE.md) —
which means the pictures have to cross into the webview and the bytes have to
come back. These four commands are that round trip: three that read what a
@@ -2577,7 +2577,7 @@ fn release_generated_frames(job_id: String) -> bool {
/* ── Exit guard ──────────────────────────────────────────────────────────────
The video engine runs inside this process, so closing the window ends a
-generation outright — and vidfab writes no file of its own, so an unfinished
+generation outright — and slopfab writes no file of its own, so an unfinished
run leaves nothing behind. The webview therefore has to be able to answer the
close request before the window goes away.
@@ -2708,7 +2708,7 @@ pub fn run() {
Ok(())
})
.manage(agent::AgentRuntime::default())
- .manage(vidfab::VidfabRuntime::default())
+ .manage(slopfab::SlopfabRuntime::default())
.manage(ExitGuard::default())
.on_window_event(|window, event| {
use tauri::{Emitter as _, Manager as _};
@@ -2749,14 +2749,14 @@ pub fn run() {
save_project,
runtime_status,
list_agent_models,
- vidfab_status,
+ slopfab_status,
choose_engine_path,
run_agent_turn,
execute_agent_commands,
cancel_agent_turn,
- resolve_vidfab_plan,
- enqueue_vidfab_generation,
- cancel_vidfab_generation,
+ resolve_slopfab_plan,
+ enqueue_slopfab_generation,
+ cancel_slopfab_generation,
set_generation_active,
answer_app_close,
write_generated_video,
diff --git a/src-tauri/src/rendered.rs b/src-tauri/src/rendered.rs
index 9f24fe2..be39bb7 100644
--- a/src-tauri/src/rendered.rs
+++ b/src-tauri/src/rendered.rs
@@ -1,6 +1,6 @@
-//! What a finished generation leaves behind, between vidfab and the encoder.
+//! What a finished generation leaves behind, between slopfab and the encoder.
//!
-//! vidfab hands back raw pictures — planar RGB floats, one channel after
+//! slopfab hands back raw pictures — planar RGB floats, one channel after
//! another, with every frame of a channel contiguous — and frees them when the
//! generation handle is destroyed. Nothing in this process can turn those into
//! an MP4: encoding is the webview's job, because WebCodecs owns the OS encoder
@@ -8,12 +8,12 @@
//! CLAUDE.md on the licensing reason).
//!
//! So this module is the hand-off. It keeps the finished generation handle
-//! alive, asks vidfab to convert only the frame the webview currently needs,
+//! alive, asks slopfab to convert only the frame the webview currently needs,
//! and releases the handle after WebCodecs has encoded and muxed the file.
//!
//! ## What this costs
//!
-//! Only one RGBA frame is allocated per IPC request. Vidfab's decoded planar
+//! Only one RGBA frame is allocated per IPC request. Slopfab's decoded planar
//! floats remain owned by its generation handle, avoiding the former second
//! whole-video allocation and eager conversion pass.
//!
@@ -38,7 +38,7 @@ pub trait FrameSource: Send {
fn frame_rgba(&self, index: u32, width: u32, height: u32) -> Result<Vec<u8>, String>;
}
-/// A finished render whose vidfab source is kept alive until encoding ends.
+/// A finished render whose slopfab source is kept alive until encoding ends.
pub struct RenderedVideo {
pub job_id: String,
pub width: u32,
@@ -46,7 +46,7 @@ pub struct RenderedVideo {
pub frame_count: u32,
pub fps: f64,
source: Box<dyn FrameSource>,
- /// Interleaved samples, as vidfab returned them.
+ /// Interleaved samples, as slopfab returned them.
audio: Vec<f32>,
pub audio_channels: u32,
pub audio_sample_rate: u32,
@@ -74,7 +74,7 @@ impl RenderedVideo {
}
}
-/// How the floats vidfab returns map onto 0–255.
+/// How the floats slopfab returns map onto 0–255.
///
/// The C API documents the layout (planar RGB) but not the range, and the two
/// conventions a decoder can use — 0…1 and −1…1 — differ by a factor of two and
@@ -120,7 +120,7 @@ impl Range {
}
}
-/// Turns vidfab's planar float pictures into the RGBA the webview can encode.
+/// Turns slopfab's planar float pictures into the RGBA the webview can encode.
///
/// The C API declares the layout as `[channels][frames][height][width]`: all
/// red frames first, then all green frames, then all blue frames. In
@@ -192,7 +192,7 @@ pub fn rgba_from_planar(
Ok(rgba)
}
-/// Builds the hand-off around a source that owns the finished vidfab handle.
+/// Builds the hand-off around a source that owns the finished slopfab handle.
#[allow(clippy::too_many_arguments)]
pub fn from_source(
job_id: &str,
@@ -395,7 +395,7 @@ mod tests {
#[test]
fn channel_major_frames_are_not_read_as_repeated_temporal_blocks() {
- // [R0, R1, G0, G1, B0, B1], exactly as vidfab's C API returns it.
+ // [R0, R1, G0, G1, B0, B1], exactly as slopfab's C API returns it.
// Distinct channels and frames make a channel/frame transposition
// visible instead of letting a greyscale fixture hide it.
let video = vec![0.1, 0.4, 0.2, 0.5, 0.3, 0.6];
diff --git a/src-tauri/src/vidfab.rs b/src-tauri/src/slopfab.rs
similarity index 91%
rename from src-tauri/src/vidfab.rs
rename to src-tauri/src/slopfab.rs
index 3fce7d8..0e05ce7 100644
--- a/src-tauri/src/vidfab.rs
+++ b/src-tauri/src/slopfab.rs
@@ -1,4 +1,4 @@
-//! Safe host-side boundary for the dynamically loaded vidfab C API.
+//! Safe host-side boundary for the dynamically loaded slopfab C API.
//!
//! All ABI declarations and `unsafe` calls live in `ffi`; the rest of the
//! application only handles owned Rust status, plan, progress, and metadata.
@@ -16,14 +16,14 @@ use std::{
};
use tauri::{AppHandle, Emitter};
-const DLL_FILE_NAME: &str = "vidfab.dll";
+const DLL_FILE_NAME: &str = "slopfab.dll";
/// Where the packaged build puts the runtime while it is being developed. Used
/// only when the DLL is NOT beside the executable, so a `cargo run` out of the
/// source tree still finds it.
-const DEVELOPMENT_DLL_PATH: &str = r"D:\Projects\vidfab\build\Release\vidfab.dll";
+const DEVELOPMENT_DLL_PATH: &str = r"D:\Projects\slopfab\build\Release\slopfab.dll";
/// The runtime ships beside PolStudio.exe and is loaded from there — there is
-/// no path for anyone to configure and no way for one to go stale. vidfab.dll
+/// no path for anyone to configure and no way for one to go stale. slopfab.dll
/// is loaded with LOAD_WITH_ALTERED_SEARCH_PATH, so its own dependencies sit in
/// that folder too, which is the same reason a subfolder never bought anything.
pub fn default_dll_path() -> PathBuf {
@@ -83,7 +83,7 @@ fn platform_from_cuda_probe(result: Result<i32, String>) -> ComputePlatform {
fn detect_platform(api: &ffi::Api) -> ComputePlatform {
// Explicit "auto" makes PolStudio's order deterministic even if the host
- // process carries VIDFAB_CUDA_VERSION. If this DLL instance was already
+ // process carries SLOPFAB_CUDA_VERSION. If this DLL instance was already
// initialized, the setter is expected to refuse the change and the loaded
// major below remains the authority.
let _ = api.set_cuda_version("auto");
@@ -92,7 +92,7 @@ fn detect_platform(api: &ffi::Api) -> ComputePlatform {
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
-pub struct VidfabStatus {
+pub struct SlopfabStatus {
pub state: &'static str,
pub dll_path: String,
pub version: Option<String>,
@@ -195,20 +195,20 @@ struct OutputMetadata {
}
#[derive(Clone)]
-pub struct VidfabRuntime {
+pub struct SlopfabRuntime {
sender: mpsc::Sender<QueueItem>,
cancellations: Arc<Mutex<HashMap<String, Arc<AtomicBool>>>>,
}
-impl Default for VidfabRuntime {
+impl Default for SlopfabRuntime {
fn default() -> Self {
let (sender, receiver) = mpsc::channel::<QueueItem>();
let cancellations = Arc::new(Mutex::new(HashMap::new()));
let worker_flags = cancellations.clone();
- thread::Builder::new().name("vidfab-serial-queue".into()).spawn(move || {
+ thread::Builder::new().name("slopfab-serial-queue".into()).spawn(move || {
while let Ok(item) = receiver.recv() {
let started = std::time::Instant::now();
- diagnostics::info("vidfab", "generation.started", "Native generation worker started.", serde_json::json!({
+ diagnostics::info("slopfab", "generation.started", "Native generation worker started.", serde_json::json!({
"jobId": item.request.job_id,
"frames": item.request.frames,
"steps": item.request.steps,
@@ -255,13 +255,13 @@ impl Default for VidfabRuntime {
})),
});
if state == "failed" {
- diagnostics::error("vidfab", "generation.finished", &detail, context);
+ diagnostics::error("slopfab", "generation.finished", &detail, context);
} else if state == "cancelled" {
- diagnostics::warn("vidfab", "generation.finished", &detail, context);
+ diagnostics::warn("slopfab", "generation.finished", &detail, context);
} else {
- diagnostics::info("vidfab", "generation.finished", &detail, context);
+ diagnostics::info("slopfab", "generation.finished", &detail, context);
}
- let _ = item.app.emit("vidfab-job", JobEvent { job_id: item.request.job_id.clone(), state, detail, output });
+ let _ = item.app.emit("slopfab-job", JobEvent { job_id: item.request.job_id.clone(), state, detail, output });
let queue_empty = if let Ok(mut flags) = worker_flags.lock() {
flags.remove(&item.request.job_id);
flags.is_empty()
@@ -274,11 +274,11 @@ impl Default for VidfabRuntime {
// the otherwise multi-gigabyte cache a deterministic lifetime.
if queue_empty {
if let Err(error) = clear_reused_models(&item.configuration) {
- diagnostics::warn("vidfab", "models.clear_failed", &error, serde_json::json!({}));
+ diagnostics::warn("slopfab", "models.clear_failed", &error, serde_json::json!({}));
}
}
}
- }).expect("could not start vidfab queue worker");
+ }).expect("could not start slopfab queue worker");
Self {
sender,
cancellations,
@@ -292,7 +292,7 @@ fn clear_reused_models(configuration: &Configuration) -> Result<(), String> {
api.clear_reused_models()
}
-impl VidfabRuntime {
+impl SlopfabRuntime {
pub fn enqueue(
&self,
app: AppHandle,
@@ -300,7 +300,7 @@ impl VidfabRuntime {
settings: &BTreeMap<String, ProviderSetting>,
) -> Result<(), String> {
diagnostics::info(
- "vidfab",
+ "slopfab",
"generation.enqueue_requested",
"Generation was submitted to the native queue.",
serde_json::json!({
@@ -346,16 +346,16 @@ impl VidfabRuntime {
return Err("Generation queue is unavailable.".into());
}
let _ = app.emit(
- "vidfab-job",
+ "slopfab-job",
JobEvent {
job_id: queued_id.clone(),
state: "queued",
- detail: "Queued behind any active vidfab generation.".into(),
+ detail: "Queued behind any active slopfab generation.".into(),
output: None,
},
);
diagnostics::info(
- "vidfab",
+ "slopfab",
"generation.queued",
"Generation entered the native queue.",
serde_json::json!({ "jobId": queued_id }),
@@ -374,7 +374,7 @@ impl VidfabRuntime {
true
});
diagnostics::info(
- "vidfab",
+ "slopfab",
"generation.cancel_requested",
if accepted {
"Cancellation was accepted."
@@ -404,9 +404,9 @@ struct Configuration {
impl Configuration {
fn from_settings(settings: &BTreeMap<String, ProviderSetting>) -> Self {
- let vidfab = settings.get("vidfab");
+ let slopfab = settings.get("slopfab");
let option = |name: &str| {
- vidfab.and_then(|setting| match setting.options.get(name) {
+ slopfab.and_then(|setting| match setting.options.get(name) {
Some(ProviderOption::String(value)) if !value.trim().is_empty() => {
Some(PathBuf::from(value))
}
@@ -443,11 +443,11 @@ impl Configuration {
})
.collect::<Vec<_>>()
.join(";");
- format!("vidfab={version}|platform={}|{models}", platform.label())
+ format!("slopfab={version}|platform={}|{models}", platform.label())
}
}
-pub fn status(settings: &BTreeMap<String, ProviderSetting>) -> VidfabStatus {
+pub fn status(settings: &BTreeMap<String, ProviderSetting>) -> SlopfabStatus {
let configuration = Configuration::from_settings(settings);
let models = configuration
.models
@@ -470,7 +470,7 @@ pub fn status(settings: &BTreeMap<String, ProviderSetting>) -> VidfabStatus {
.iter()
.filter(|model| !model.available && model.id != "tokenizer")
.count();
- VidfabStatus {
+ SlopfabStatus {
state: if missing == 0 {
"ready"
} else {
@@ -487,7 +487,7 @@ pub fn status(settings: &BTreeMap<String, ProviderSetting>) -> VidfabStatus {
models,
}
}
- Err(error) => VidfabStatus {
+ Err(error) => SlopfabStatus {
state: "incompatible",
dll_path,
version: None,
@@ -496,12 +496,12 @@ pub fn status(settings: &BTreeMap<String, ProviderSetting>) -> VidfabStatus {
models,
},
},
- Err(error) => VidfabStatus {
+ Err(error) => SlopfabStatus {
state: "runtimeMissing",
dll_path,
version: None,
platform: None,
- detail: format!("vidfab is unavailable: {error}. Editing remains available."),
+ detail: format!("slopfab is unavailable: {error}. Editing remains available."),
models,
},
}
@@ -590,7 +590,7 @@ fn configure_request(
}
/// Runs one generation and retains its terminal handle for frame streaming.
-/// Audio is copied once; video stays owned by vidfab until encoding completes.
+/// Audio is copied once; video stays owned by slopfab until encoding completes.
struct FinishedGeneration {
api: ffi::Api,
generation: *mut ffi::Generation,
@@ -621,9 +621,9 @@ fn run_generation(item: &QueueItem) -> Result<(OutputMetadata, rendered::Rendere
let platform = detect_platform(&api);
let timing_profile = item.configuration.timing_profile(&version, platform);
diagnostics::debug(
- "vidfab",
+ "slopfab",
"generation.runtime_ready",
- "vidfab runtime loaded.",
+ "slopfab runtime loaded.",
serde_json::json!({
"jobId": item.request.job_id, "version": version, "platform": platform.label(),
}),
@@ -639,9 +639,9 @@ fn run_generation(item: &QueueItem) -> Result<(OutputMetadata, rendered::Rendere
)?;
api.resolve(request.0)?;
diagnostics::debug(
- "vidfab",
+ "slopfab",
"generation.request_resolved",
- "vidfab resolved the generation request.",
+ "slopfab resolved the generation request.",
serde_json::json!({ "jobId": item.request.job_id }),
);
let context = Box::new(CallbackContext {
@@ -665,9 +665,9 @@ fn run_generation(item: &QueueItem) -> Result<(OutputMetadata, rendered::Rendere
}
};
diagnostics::debug(
- "vidfab",
+ "slopfab",
"generation.api_started",
- "vidfab accepted the generation request.",
+ "slopfab accepted the generation request.",
serde_json::json!({ "jobId": item.request.job_id }),
);
loop {
@@ -683,7 +683,7 @@ fn run_generation(item: &QueueItem) -> Result<(OutputMetadata, rendered::Rendere
unsafe {
drop(Box::from_raw(context_ptr));
}
- return Err("Generation cancelled at the next vidfab checkpoint.".into());
+ return Err("Generation cancelled at the next slopfab checkpoint.".into());
}
if code != 0 {
let error = api.generation_error(generation);
@@ -692,7 +692,7 @@ fn run_generation(item: &QueueItem) -> Result<(OutputMetadata, rendered::Rendere
drop(Box::from_raw(context_ptr));
}
return Err(if error.is_empty() {
- format!("vidfab generation failed with status {code}.")
+ format!("slopfab generation failed with status {code}.")
} else {
error
});
@@ -710,7 +710,7 @@ fn run_generation(item: &QueueItem) -> Result<(OutputMetadata, rendered::Rendere
if output.audio.is_null() && output.audio_float_count != 0 {
api.destroy_generation(generation);
unsafe { drop(Box::from_raw(context_ptr)) };
- return Err("Vidfab returned a null audio buffer with a non-zero size.".into());
+ return Err("Slopfab returned a null audio buffer with a non-zero size.".into());
}
// Audio is small enough to own directly. Video remains in the generation
// and is converted through frame_rgba8 only as WebCodecs asks for it.
@@ -737,7 +737,7 @@ fn run_generation(item: &QueueItem) -> Result<(OutputMetadata, rendered::Rendere
} else {
0.0
},
- boundary: "Decoded buffers remain owned by vidfab and frames are converted on demand. The webview encodes them; vidfab wrote no file.",
+ boundary: "Decoded buffers remain owned by slopfab and frames are converted on demand. The webview encodes them; slopfab wrote no file.",
};
unsafe {
drop(Box::from_raw(context_ptr));
@@ -822,7 +822,7 @@ fn write_reference_icon(
if status != 0 {
let detail = api.generation_error(generation.0);
return Err(if detail.is_empty() {
- format!("Icon '{}' failed with vidfab status {status}.", spec.id)
+ format!("Icon '{}' failed with slopfab status {status}.", spec.id)
} else {
format!("Icon '{}' failed: {detail}", spec.id)
});
@@ -927,9 +927,9 @@ unsafe extern "C" fn progress_callback(
let progress = unsafe { &*progress };
let context = unsafe { &*(userdata.cast::<CallbackContext>()) };
diagnostics::debug(
- "vidfab",
+ "slopfab",
"generation.progress",
- "vidfab reported progress.",
+ "slopfab reported progress.",
serde_json::json!({
"jobId": context.job_id,
"stage": stage_name(progress.stage),
@@ -940,7 +940,7 @@ unsafe extern "C" fn progress_callback(
}),
);
let _ = context.app.emit(
- "vidfab-progress",
+ "slopfab-progress",
ProgressEvent {
job_id: context.job_id.clone(),
stage: stage_name(progress.stage),
@@ -1084,90 +1084,90 @@ mod ffi {
};
}
Ok(Self {
- capi_version: symbol!("vidfab_capi_version", unsafe extern "C" fn() -> u32),
+ capi_version: symbol!("slopfab_capi_version", unsafe extern "C" fn() -> u32),
version_string: symbol!(
- "vidfab_capi_version_string",
+ "slopfab_capi_version_string",
unsafe extern "C" fn() -> *const c_char
),
last_error: symbol!(
- "vidfab_last_error",
+ "slopfab_last_error",
unsafe extern "C" fn() -> *const c_char
),
- free_string: symbol!("vidfab_free_string", unsafe extern "C" fn(*mut c_char)),
+ free_string: symbol!("slopfab_free_string", unsafe extern "C" fn(*mut c_char)),
cuda_set_version: symbol!(
- "vidfab_cuda_set_version",
+ "slopfab_cuda_set_version",
unsafe extern "C" fn(*const c_char) -> i32
),
cuda_loaded_major: symbol!(
- "vidfab_cuda_loaded_major",
+ "slopfab_cuda_loaded_major",
unsafe extern "C" fn(*mut i32) -> i32
),
request_create: symbol!(
- "vidfab_request_create",
+ "slopfab_request_create",
unsafe extern "C" fn() -> *mut Request
),
request_destroy: symbol!(
- "vidfab_request_destroy",
+ "slopfab_request_destroy",
unsafe extern "C" fn(*mut Request)
),
set_prompt: symbol!(
- "vidfab_request_set_prompt",
+ "slopfab_request_set_prompt",
unsafe extern "C" fn(*mut Request, *const c_char) -> i32
),
set_resolution: symbol!(
- "vidfab_request_set_resolution",
+ "slopfab_request_set_resolution",
unsafe extern "C" fn(*mut Request, i32, i32) -> i32
),
set_frames: symbol!(
- "vidfab_request_set_frames",
+ "slopfab_request_set_frames",
unsafe extern "C" fn(*mut Request, i32) -> i32
),
set_steps: symbol!(
- "vidfab_request_set_steps",
+ "slopfab_request_set_steps",
unsafe extern "C" fn(*mut Request, i32) -> i32
),
set_seed: symbol!(
- "vidfab_request_set_seed",
+ "slopfab_request_set_seed",
unsafe extern "C" fn(*mut Request, u64) -> i32
),
set_model: symbol!(
- "vidfab_request_set_model_path",
+ "slopfab_request_set_model_path",
unsafe extern "C" fn(*mut Request, i32, *const c_char) -> i32
),
add_reference: symbol!(
- "vidfab_request_add_reference_image",
+ "slopfab_request_add_reference_image",
unsafe extern "C" fn(*mut Request, *const c_char) -> i32
),
set_attention: symbol!(
- "vidfab_request_set_attention",
+ "slopfab_request_set_attention",
unsafe extern "C" fn(*mut Request, *const c_char) -> i32
),
set_inference_backend: symbol!(
- "vidfab_request_set_inference_backend",
+ "slopfab_request_set_inference_backend",
unsafe extern "C" fn(*mut Request, i32) -> i32
),
set_verbose: symbol!(
- "vidfab_request_set_verbose",
+ "slopfab_request_set_verbose",
unsafe extern "C" fn(*mut Request, i32) -> i32
),
set_reuse_models: symbol!(
- "vidfab_request_set_reuse_models",
+ "slopfab_request_set_reuse_models",
unsafe extern "C" fn(*mut Request, i32) -> i32
),
reused_models_clear: symbol!(
- "vidfab_reused_models_clear",
+ "slopfab_reused_models_clear",
unsafe extern "C" fn() -> i32
),
resolve_plan: symbol!(
- "vidfab_resolve_plan",
+ "slopfab_resolve_plan",
unsafe extern "C" fn(*const Request, *mut Plan) -> i32
),
describe_plan: symbol!(
- "vidfab_describe_plan",
+ "slopfab_describe_plan",
unsafe extern "C" fn(*const Request, *mut *mut c_char) -> i32
),
generation_start: symbol!(
- "vidfab_generation_start",
+ "slopfab_generation_start",
unsafe extern "C" fn(
*const Request,
ProgressFn,
@@ -1176,27 +1176,27 @@ mod ffi {
) -> i32
),
generation_cancel: symbol!(
- "vidfab_generation_cancel",
+ "slopfab_generation_cancel",
unsafe extern "C" fn(*mut Generation)
),
generation_wait: symbol!(
- "vidfab_generation_wait",
+ "slopfab_generation_wait",
unsafe extern "C" fn(*mut Generation, i32) -> i32
),
generation_error: symbol!(
- "vidfab_generation_error",
+ "slopfab_generation_error",
unsafe extern "C" fn(*const Generation) -> *const c_char
),
generation_output: symbol!(
- "vidfab_generation_output",
+ "slopfab_generation_output",
unsafe extern "C" fn(*const Generation, *mut Output) -> i32
),
generation_frame_rgba8: symbol!(
- "vidfab_generation_frame_rgba8",
+ "slopfab_generation_frame_rgba8",
unsafe extern "C" fn(*const Generation, i32, *mut u8, usize) -> i32
),
generation_destroy: symbol!(
- "vidfab_generation_destroy",
+ "slopfab_generation_destroy",
unsafe extern "C" fn(*mut Generation)
),
_library: library,
@@ -1209,7 +1209,7 @@ mod ffi {
let major = packed >> 24;
if major != super::EXPECTED_CAPI_MAJOR {
return Err(format!(
- "Incompatible vidfab C API major {major}; expected {}.",
+ "Incompatible slopfab C API major {major}; expected {}.",
super::EXPECTED_CAPI_MAJOR
));
}
@@ -1222,7 +1222,7 @@ mod ffi {
} else {
let message = unsafe { c_string((self.last_error)()) };
Err(if message.is_empty() {
- format!("vidfab returned status {code}.")
+ format!("slopfab returned status {code}.")
} else {
message
})
@@ -1369,7 +1369,7 @@ mod ffi {
height: u32,
) -> Result<Vec<u8>, String> {
let index = i32::try_from(index)
- .map_err(|_| "Frame index does not fit the vidfab API.".to_string())?;
+ .map_err(|_| "Frame index does not fit the slopfab API.".to_string())?;
let bytes = (width as usize)
.checked_mul(height as usize)
.and_then(|value| value.checked_mul(4))
@@ -1386,7 +1386,7 @@ mod ffi {
}
fn path_cstring(path: &Path) -> Result<CString, String> {
CString::new(path.to_string_lossy().as_bytes())
- .map_err(|_| "A vidfab path contains a null byte.".into())
+ .map_err(|_| "A slopfab path contains a null byte.".into())
}
#[cfg(windows)]
@@ -1422,13 +1422,13 @@ mod tests {
fn absent_dll_is_an_explicit_disabled_state() {
let mut settings = BTreeMap::new();
settings.insert(
- "vidfab".into(),
+ "slopfab".into(),
ProviderSetting {
enabled: true,
model: None,
options: BTreeMap::from([(
"dllPath".into(),
- ProviderOption::String("Z:/definitely-absent/vidfab.dll".into()),
+ ProviderOption::String("Z:/definitely-absent/slopfab.dll".into()),
)]),
},
);
diff --git a/src/App.tsx b/src/App.tsx
index c0ef3ea..334908d 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -208,7 +208,7 @@ function App() {
if (activeProject) {
return <>
- <ProjectWorkspace project={activeProject} initialView={activeProjectInitialView} runtime={runtime} onGeneratorRuntimeChange={(vidfab) => setRuntime((current) => ({ providers: current?.providers ?? CHECKING_PROVIDERS, vidfab }))} onOngoingGenerationsChange={setOngoingGenerations} onBack={() => setActiveProject(null)} onSave={async (project) => {
+ <ProjectWorkspace project={activeProject} initialView={activeProjectInitialView} runtime={runtime} onGeneratorRuntimeChange={(slopfab) => setRuntime((current) => ({ providers: current?.providers ?? CHECKING_PROVIDERS, slopfab }))} onOngoingGenerationsChange={setOngoingGenerations} onBack={() => setActiveProject(null)} onSave={async (project) => {
const saved = await saveProject(project);
setActiveProject(saved);
setProjects((current) => [saved, ...current.filter((item) => item.config.id !== saved.config.id)]);
diff --git a/src/components/ExitGuardDialog.tsx b/src/components/ExitGuardDialog.tsx
index 863387f..6ab93a5 100644
--- a/src/components/ExitGuardDialog.tsx
+++ b/src/components/ExitGuardDialog.tsx
@@ -18,8 +18,8 @@ const FOCUSABLE = "button:not([disabled]), [href], input, select, textarea, [tab
/** Asks before an exit that would throw away work the engine is still doing.
*
* Every claim it makes is a claim about this codebase, not a hedge:
- * • vidfab writes no file of its own (see `run_generation` in vidfab.rs). Its
- * frames reach the app through the `vidfab-job` event, and only once the
+ * • slopfab writes no file of its own (see `run_generation` in slopfab.rs). Its
+ * frames reach the app through the `slopfab-job` event, and only once the
* app has encoded them (useGenerationEvents → lib/generatedVideo.ts) is
* there an .mp4 in the project folder. Leave before that and there is
* nothing on disk to come back to — which is why a scene that is still
diff --git a/src/components/ProjectWorkspace.test.ts b/src/components/ProjectWorkspace.test.ts
index abcd956..6cdd986 100644
--- a/src/components/ProjectWorkspace.test.ts
+++ b/src/components/ProjectWorkspace.test.ts
@@ -168,7 +168,7 @@ describe("project workspace timecode", () => {
initialView: "timeline",
runtime: {
providers: [{ id: "codex", label: "Codex", state: "ready", executable: "codex", version: "test", detail: "Ready" }],
- vidfab: { state: "demo", dllPath: "Browser demo", version: null, platform: null, detail: "Demo", models: [] },
+ slopfab: { state: "demo", dllPath: "Browser demo", version: null, platform: null, detail: "Demo", models: [] },
},
onBack: () => undefined,
onSave: async () => undefined,
@@ -244,9 +244,9 @@ describe("project workspace timecode", () => {
onBack: () => undefined,
onSave,
}));
- await waitFor(() => expect(handlers.has("vidfab-job")).toBe(true));
+ await waitFor(() => expect(handlers.has("slopfab-job")).toBe(true));
await act(async () => {
- handlers.get("vidfab-job")?.({ payload: { jobId, state: "framesReady", detail: "Frames ready." } });
+ handlers.get("slopfab-job")?.({ payload: { jobId, state: "framesReady", detail: "Frames ready." } });
await Promise.resolve();
});
await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
diff --git a/src/components/ProjectWorkspace.tsx b/src/components/ProjectWorkspace.tsx
index fcb6886..aee907c 100644
--- a/src/components/ProjectWorkspace.tsx
+++ b/src/components/ProjectWorkspace.tsx
@@ -2,7 +2,7 @@ import { ArrowLeft, BookOpen, Bot, Download, Film, Save, Sparkles } from "lucide
import { useEffect, useMemo, useRef, useState } from "react";
import { describeDiagnosticError, errorContext, writeDiagnostic } from "../lib/diagnostics";
import type { GenerationJob, ProjectConfig, ProjectRecord } from "../lib/project";
-import { cancelVidfabGeneration, CHECKING_PROVIDERS, executeAgentCommands, type RuntimeStatus, type VidfabStatus } from "../lib/runtime";
+import { cancelSlopfabGeneration, CHECKING_PROVIDERS, executeAgentCommands, type RuntimeStatus, type SlopfabStatus } from "../lib/runtime";
import { purgeTimelineThumbnails } from "../lib/timelineThumbnails";
import { ExitGuardDialog, type OngoingGeneration } from "./ExitGuardDialog";
import { AgentDock } from "./workspace/AgentDock";
@@ -49,7 +49,7 @@ export function ProjectWorkspace({ project, initialView = "timeline", runtime =
onOngoingGenerationsChange?: (jobs: OngoingGeneration[]) => void;
/** Keeps the app-wide probe result aligned when the active generator is
* changed directly from the Generator screen. */
- onGeneratorRuntimeChange?: (runtime: VidfabStatus) => void;
+ onGeneratorRuntimeChange?: (runtime: SlopfabStatus) => void;
}) {
const [config, setConfigState] = useState(project.config);
const configRef = useRef(config);
@@ -166,7 +166,7 @@ export function ProjectWorkspace({ project, initialView = "timeline", runtime =
belong to this component and go with it. Rather than burn the GPU for a
result no one will keep, the runs are stopped the same way their own stop
button stops them. */
- ongoing.forEach((job) => { void cancelVidfabGeneration(job.id).catch(() => undefined); });
+ ongoing.forEach((job) => { void cancelSlopfabGeneration(job.id).catch(() => undefined); });
onBack();
};
@@ -241,7 +241,7 @@ export function ProjectWorkspace({ project, initialView = "timeline", runtime =
<div className={`project-content project-content--${view}`}>
{view === "timeline" && <TimelineView config={config} folderPath={project.folderPath} generationCompletionTimes={generationCompletionTimes} onChange={changeConfig} onMeasured={recordMeasurement} onOpenGenerator={(jobId) => { setSelectedGenerationJobId(jobId); setView("generator"); }} />}
- {view === "generator" && <GeneratorView config={config} folderPath={project.folderPath} generationCompletionTimes={generationCompletionTimes} runtime={runtime?.vidfab ?? null} onRuntimeChange={onGeneratorRuntimeChange} onChange={changeConfig} selectedJobId={selectedGenerationJobId} onOpenTimeline={() => setView("timeline")} />}
+ {view === "generator" && <GeneratorView config={config} folderPath={project.folderPath} generationCompletionTimes={generationCompletionTimes} runtime={runtime?.slopfab ?? null} onRuntimeChange={onGeneratorRuntimeChange} onChange={changeConfig} selectedJobId={selectedGenerationJobId} onOpenTimeline={() => setView("timeline")} />}
{view === "references" && <ReferencesView config={config} folderPath={project.folderPath} onChange={changeConfig} />}
{view === "export" && <ExportView config={config} folderPath={project.folderPath} />}
</div>
diff --git a/src/components/PromptComposer.tsx b/src/components/PromptComposer.tsx
index 57c9cbe..8b3aecd 100644
--- a/src/components/PromptComposer.tsx
+++ b/src/components/PromptComposer.tsx
@@ -17,7 +17,7 @@ const aspectRatioLabels: Record<AspectRatio, string> = {
"4:5": "Portrait 4:5",
};
-/* Chosen because it is the closest rung to the canvas vidfab actually plans a
+/* Chosen because it is the closest rung to the canvas slopfab actually plans a
16:9 scene onto (1344×768), so a project made without opening this panel is
not one that has to be rescaled the moment a scene is generated. */
const DEFAULT_RESOLUTION: Resolution = "768p";
diff --git a/src/components/SettingsView.test.tsx b/src/components/SettingsView.test.tsx
index dad1fcd..b659c32 100644
--- a/src/components/SettingsView.test.tsx
+++ b/src/components/SettingsView.test.tsx
@@ -53,7 +53,7 @@ describe("the settings screen", () => {
Object.defineProperty(window, "__TAURI_INTERNALS__", { configurable: true, value: {} });
vi.mocked(invoke).mockResolvedValue({
state: "ready",
- dllPath: "C:\\PolStudio\\vidfab.dll",
+ dllPath: "C:\\PolStudio\\slopfab.dll",
version: "1.4.0",
platform: "CUDA 13",
detail: "Ready.",
@@ -171,7 +171,7 @@ describe("the settings screen", () => {
};
vi.mocked(invoke).mockImplementation(async (command) => command === "diagnostic_log_info" || command === "reveal_diagnostic_log"
? info
- : { state: "ready", dllPath: "C:\\PolStudio\\vidfab.dll", version: "1.4.0", platform: "CUDA 13", detail: "Ready.", models: [] });
+ : { state: "ready", dllPath: "C:\\PolStudio\\slopfab.dll", version: "1.4.0", platform: "CUDA 13", detail: "Ready.", models: [] });
open();
fireEvent.click(tab("Diagnostics"));
diff --git a/src/components/SettingsView.tsx b/src/components/SettingsView.tsx
index 0d23623..b611426 100644
--- a/src/components/SettingsView.tsx
+++ b/src/components/SettingsView.tsx
@@ -2,7 +2,7 @@ import { AlertCircle, Check, ChevronLeft, FileText, FolderOpen, FolderSearch, Lo
import { useCallback, useEffect, useState } from "react";
import { getDiagnosticLogInfo, revealDiagnosticLog, type DiagnosticLogInfo } from "../lib/diagnostics";
import { isTauri } from "../lib/persistence";
-import { chooseEnginePath, getAgentModels, getEngineStatus, type ModelStatus, type VidfabStatus } from "../lib/runtime";
+import { chooseEnginePath, getAgentModels, getEngineStatus, type ModelStatus, type SlopfabStatus } from "../lib/runtime";
import {
EMPTY_ENGINE_SETTINGS, ENGINE_PATH_FIELDS,
createGeneratorTemplate, defaultGeneratorTemplate,
@@ -19,7 +19,7 @@ import {
type PathState = "unset" | "checking" | "found" | "missing";
-function pathState(field: EnginePathField, value: string, status: VidfabStatus | null): PathState {
+function pathState(field: EnginePathField, value: string, status: SlopfabStatus | null): PathState {
if (!value.trim()) return "unset";
if (!status) return "checking";
const model: ModelStatus | undefined = status.models.find((item) => item.id === field.id);
@@ -235,7 +235,7 @@ export function SettingsView({ onClose }: { onClose: () => void }) {
const [tab, setTab] = useState<TabId>("engine");
const [templateSettings, setTemplateSettings] = useState<GeneratorTemplateSettings>(() => loadGeneratorTemplateSettings());
const [editingTemplateId, setEditingTemplateId] = useState<string | null>(null);
- const [status, setStatus] = useState<VidfabStatus | null>(null);
+ const [status, setStatus] = useState<SlopfabStatus | null>(null);
const [error, setError] = useState<string | null>(null);
const desktop = isTauri();
@@ -514,7 +514,7 @@ export function SettingsView({ onClose }: { onClose: () => void }) {
);
}
-const engineHeadline = (status: VidfabStatus | null, desktop: boolean) => {
+const engineHeadline = (status: SlopfabStatus | null, desktop: boolean) => {
if (!desktop) return "Browser preview";
if (!status) return "Checking this computer…";
switch (status.state) {
@@ -526,10 +526,10 @@ const engineHeadline = (status: VidfabStatus | null, desktop: boolean) => {
}
};
-const engineDetail = (status: VidfabStatus | null, desktop: boolean, missing: number) => {
+const engineDetail = (status: SlopfabStatus | null, desktop: boolean, missing: number) => {
if (!desktop) return "Paths are saved here, but only the desktop app can check them or render with them.";
if (!status) return "Looking for the engine and the model files.";
- if (status.state === "runtimeMissing") return `${status.detail} vidfab.dll should sit next to PolStudio.exe.`;
+ if (status.state === "runtimeMissing") return `${status.detail} slopfab.dll should sit next to PolStudio.exe.`;
if (status.state === "ready") return "Everything PolStudio needs to render a shot is in place.";
if (missing > 0) return `${status.detail} ${missing === 1 ? "One path" : `${missing} paths`} still need setting below.`;
return status.detail;
diff --git a/src/components/workspace/GeneratorView.test.tsx b/src/components/workspace/GeneratorView.test.tsx
index aafab1a..b3c4a82 100644
--- a/src/components/workspace/GeneratorView.test.tsx
+++ b/src/components/workspace/GeneratorView.test.tsx
@@ -5,12 +5,12 @@ import { act, cleanup, fireEvent, render, screen, waitFor, within } from "@testi
import { useState } from "react";
import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
import { createDraftGenerationJob, createProjectConfig, parseProjectConfig, sceneShots, type ProjectConfig } from "../../lib/project";
-import { cancelVidfabGeneration, getEngineStatus, type VidfabStatus } from "../../lib/runtime";
+import { cancelSlopfabGeneration, getEngineStatus, type SlopfabStatus } from "../../lib/runtime";
import { GeneratorView } from "./GeneratorView";
vi.mock("../../lib/runtime", async (importOriginal) => ({
...await importOriginal<typeof import("../../lib/runtime")>(),
- cancelVidfabGeneration: vi.fn().mockResolvedValue(true),
+ cancelSlopfabGeneration: vi.fn().mockResolvedValue(true),
getEngineStatus: vi.fn(),
}));
@@ -21,7 +21,7 @@ beforeEach(() => {
});
afterEach(cleanup);
-const readyRuntime: VidfabStatus = {
+const readyRuntime: SlopfabStatus = {
state: "ready",
dllPath: "test",
version: "test",
@@ -487,17 +487,17 @@ describe("Generator scene controls", () => {
expect(within(first).queryByText("RENDERING")).not.toBeInTheDocument();
fireEvent.click(within(first).getByRole("button", { name: "Cancel" }));
- await waitFor(() => expect(cancelVidfabGeneration).toHaveBeenCalledWith("scene-first"));
+ await waitFor(() => expect(cancelSlopfabGeneration).toHaveBeenCalledWith("scene-first"));
const cancelling = within(first).getAllByRole("img", { name: /Cancelling\.\.\.$/ });
expect(cancelling).toHaveLength(2);
expect(cancelling.every((thumbnail) => thumbnail.querySelector(".spin"))).toBe(true);
expect(within(first).queryByText("Rendering 42%")).not.toBeInTheDocument();
- vi.mocked(cancelVidfabGeneration).mockClear();
+ vi.mocked(cancelSlopfabGeneration).mockClear();
fireEvent.click(screen.getByRole("button", { name: "Cancel All" }));
await waitFor(() => {
- expect(cancelVidfabGeneration).toHaveBeenCalledTimes(1);
- expect(cancelVidfabGeneration).toHaveBeenCalledWith("scene-second");
+ expect(cancelSlopfabGeneration).toHaveBeenCalledTimes(1);
+ expect(cancelSlopfabGeneration).toHaveBeenCalledWith("scene-second");
});
});
});
diff --git a/src/components/workspace/GeneratorView.tsx b/src/components/workspace/GeneratorView.tsx
index 32cc984..5c1f34f 100644
--- a/src/components/workspace/GeneratorView.tsx
+++ b/src/components/workspace/GeneratorView.tsx
@@ -5,7 +5,7 @@ import { describeDiagnosticError, errorContext, writeDiagnostic } from "../../li
import { actionReferenceIds, compileGenerationJobPrompt, compileGenerationJobSegments, createDraftGenerationJob, danglingReferenceTokens, GENERATION_FRAME_RATE, RANDOM_GENERATION_SEED, sceneDurationSeconds, sceneGenerationReferences, sceneGenerationSeed, sceneGenerationSnapshot, sceneGenerationSteps, sceneShots, SCENE_MAX_SECONDS, SCENE_MIN_SECONDS, projectItemPath, usableReferenceImages, type GenerationJob, type ProjectConfig, type ProjectReference, type PromptSegment, type SceneShot } from "../../lib/project";
import { generationDimensions } from "../../lib/export";
import { isTauri } from "../../lib/persistence";
-import { cancelVidfabGeneration, enqueueVidfabGeneration, getEngineStatus, resolveVidfabPlan, type VidfabGenerationRequest, type VidfabStatus } from "../../lib/runtime";
+import { cancelSlopfabGeneration, enqueueSlopfabGeneration, getEngineStatus, resolveSlopfabPlan, type SlopfabGenerationRequest, type SlopfabStatus } from "../../lib/runtime";
import { SceneBoard, type GeneratorSelection } from "./SceneBoard";
import { SceneInspector, ShotInspector, STEP_SECONDS, writeShots } from "./SceneEditor";
import { statusIcon } from "./sceneStatus";
@@ -16,12 +16,12 @@ import { defaultGeneratorTemplate, loadGeneratorTemplateSettings, saveGeneratorT
interface GeneratorViewProps {
config: ProjectConfig;
folderPath: string;
- runtime?: VidfabStatus | null;
+ runtime?: SlopfabStatus | null;
generationCompletionTimes?: Readonly<Record<string, number>>;
onChange: (next: ProjectConfig) => void;
onOpenTimeline: () => void;
selectedJobId?: string;
- onRuntimeChange?: (runtime: VidfabStatus) => void;
+ onRuntimeChange?: (runtime: SlopfabStatus) => void;
}
type RemovalTarget =
@@ -44,17 +44,17 @@ export function GeneratorView({ config, folderPath, runtime = null, generationCo
const [templateSettings, setTemplateSettings] = useState(loadGeneratorTemplateSettings);
const selectedTemplate = defaultGeneratorTemplate(templateSettings);
const defaultGenerationSteps = selectedTemplate.defaultSteps;
- const [generatorRuntime, setGeneratorRuntime] = useState<VidfabStatus | null>(runtime);
+ const [generatorRuntime, setGeneratorRuntime] = useState<SlopfabStatus | null>(runtime);
const [runtimeError, setRuntimeError] = useState<string | null>(null);
const runtimeProbe = useRef(0);
const configRef = useRef(config);
configRef.current = config;
// A scene is displayed as queued while its plan is resolving, just before
// the backend receives it. Remember cancellation here as well as sending it
- // to vidfab, so a click in that small window prevents the later enqueue.
+ // to slopfab, so a click in that small window prevents the later enqueue.
const cancellationRequests = useRef(new Set<string>());
// The ref above protects asynchronous work; this set exists so the cards
- // repaint immediately when Cancel is pressed, before vidfab reports the
+ // repaint immediately when Cancel is pressed, before slopfab reports the
// terminal cancelled state.
const [cancellingJobIds, setCancellingJobIds] = useState<ReadonlySet<string>>(() => new Set());
@@ -264,10 +264,10 @@ export function GeneratorView({ config, folderPath, runtime = null, generationCo
setSelection({ jobId: target.id, shotId });
};
- const requestFor = (job: GenerationJob): VidfabGenerationRequest => {
+ const requestFor = (job: GenerationJob): SlopfabGenerationRequest => {
// Only the references actually bound to this scene, in list order. The same
// ordered list drives the <Subject N> / <Picture N> numbering inside the
- // compiled prompt, because vidfab.rs adds reference_paths sequentially — so
+ // compiled prompt, because slopfab.rs adds reference_paths sequentially — so
// array index 0 must be the asset the prompt calls <Picture 1>.
const bound = sceneGenerationReferences(job, configRef.current.references);
const canvas = generationDimensions(config.settings.resolution, config.settings.aspectRatio);
@@ -275,7 +275,7 @@ export function GeneratorView({ config, folderPath, runtime = null, generationCo
jobId: job.id,
// Recompiled from current state so edits to a bound reference or a
// retimed shot reach the engine, rather than sending a prompt frozen at
- // draft-creation time. This is the ONE string vidfab is given, and it is
+ // draft-creation time. This is the ONE string slopfab is given, and it is
// the same string the compiled-prompt panel shows.
prompt: compileGenerationJobPrompt(job, bound),
// The scene's own length, not a fixed six seconds.
@@ -293,7 +293,7 @@ export function GeneratorView({ config, folderPath, runtime = null, generationCo
const snapshotFor = (job: GenerationJob, request = requestFor(job)): string =>
sceneGenerationSnapshot(job, request);
- const logRequest = (event: string, message: string, request: VidfabGenerationRequest) => writeDiagnostic("info", "generator", event, message, {
+ const logRequest = (event: string, message: string, request: SlopfabGenerationRequest) => writeDiagnostic("info", "generator", event, message, {
jobId: request.jobId,
frames: request.frames,
steps: request.steps,
@@ -339,7 +339,7 @@ export function GeneratorView({ config, folderPath, runtime = null, generationCo
if (runtimeReady) {
logRequest("generation.retry_requested", "Generation retry requested.", request);
try {
- await enqueueVidfabGeneration(request, configRef.current);
+ await enqueueSlopfabGeneration(request, configRef.current);
} catch (reason) {
updateJob(job.id, { status: "failed", stage: "failed", error: logFailure("generation.retry_failed", job.id, reason) });
}
@@ -368,7 +368,7 @@ export function GeneratorView({ config, folderPath, runtime = null, generationCo
const at = current.generationJobs.findIndex((item) => item.id === job.id);
if (at < 0) return;
void purgeSceneThumbnails(job);
- if (job.status === "generating" || job.status === "queued") void cancelVidfabGeneration(job.id);
+ if (job.status === "generating" || job.status === "queued") void cancelSlopfabGeneration(job.id);
const generationJobs = current.generationJobs.filter((item) => item.id !== job.id);
onChange({ ...current, generationJobs });
if (selection.jobId === job.id) {
@@ -399,10 +399,10 @@ export function GeneratorView({ config, folderPath, runtime = null, generationCo
composer used to do this for a scene it had just created; a scene is
now created empty and generated from here, so the plan is resolved
here or nobody ever sees it. */
- const plan = await resolveVidfabPlan(request, configRef.current);
+ const plan = await resolveSlopfabPlan(request, configRef.current);
setPlanNotes((current) => ({ ...current, [job.id]: `Planned as ${plan.alignedFrames} frames at ${plan.canvasWidth}×${plan.canvasHeight}. ${plan.boundary}` }));
if (cancellationRequests.current.has(job.id)) return;
- await enqueueVidfabGeneration(request, configRef.current);
+ await enqueueSlopfabGeneration(request, configRef.current);
} catch (reason) {
if (cancellationRequests.current.has(job.id)) return;
updateJob(job.id, { status: "failed", stage: "failed", error: logFailure("generation.prepare_failed", job.id, reason) });
@@ -418,14 +418,14 @@ export function GeneratorView({ config, folderPath, runtime = null, generationCo
setCancellingJobIds((current) => new Set([...current, ...next.map((job) => job.id)]));
const accepted = await Promise.all(next.map(async (job) => {
try {
- return await cancelVidfabGeneration(job.id);
+ return await cancelSlopfabGeneration(job.id);
} catch (reason) {
logFailure("generation.cancel_failed", job.id, reason);
return false;
}
}));
// False means the scene was still in frontend planning and never reached
- // vidfab. No backend event will arrive for it, so finish that cancellation
+ // slopfab. No backend event will arrive for it, so finish that cancellation
// locally; accepted cancellations are finalized by the normal event path.
const beforeEnqueue = new Set(next.filter((_, index) => !accepted[index]).map((job) => job.id));
if (beforeEnqueue.size > 0) {
@@ -485,10 +485,10 @@ export function GeneratorView({ config, folderPath, runtime = null, generationCo
for (const { job, request } of requests) {
if (cancellationRequests.current.has(job.id)) continue;
try {
- const plan = await resolveVidfabPlan(request, current);
+ const plan = await resolveSlopfabPlan(request, current);
setPlanNotes((notes) => ({ ...notes, [job.id]: `Planned as ${plan.alignedFrames} frames at ${plan.canvasWidth}×${plan.canvasHeight}. ${plan.boundary}` }));
if (cancellationRequests.current.has(job.id)) continue;
- await enqueueVidfabGeneration(request, current);
+ await enqueueSlopfabGeneration(request, current);
} catch (reason) {
if (cancellationRequests.current.has(job.id)) continue;
updateJob(job.id, { status: "failed", stage: "failed", error: logFailure("generation.prepare_failed", job.id, reason) });
@@ -735,7 +735,7 @@ function sendBlocker(job: GenerationJob, references: ProjectReference[]): string
/* The compiled prompt, shown before anything is sent and coloured by who wrote
which part. The segments come from the compiler itself, so this panel is the
- string vidfab receives — not a re-rendering of it that could drift. */
+ string slopfab receives — not a re-rendering of it that could drift. */
function CompiledPrompt({ segments }: { segments: PromptSegment[] }) {
return <section className="compiled-prompt" aria-label="The compiled MiniMax H3 prompt">
<pre className="compiled-prompt__text">{segments.map((segment, index) =>
@@ -750,7 +750,7 @@ const boardSummary = (active: number, waiting: number, total: number) => {
return total === 1 ? "1 scene" : `${total} scenes`;
};
-const runtimeHeadline = (runtime: VidfabStatus | null) => {
+const runtimeHeadline = (runtime: SlopfabStatus | null) => {
if (!runtime) return "Checking for the video engine…";
switch (runtime.state) {
case "ready": return "Video generator ready";
diff --git a/src/components/workspace/SceneEditor.tsx b/src/components/workspace/SceneEditor.tsx
index d4dcb12..6d1d9d3 100644
--- a/src/components/workspace/SceneEditor.tsx
+++ b/src/components/workspace/SceneEditor.tsx
@@ -330,7 +330,7 @@ export function SceneInspector({ job, shots, references, defaultSteps, disabled,
onClick={onAddStartFrame}
><ImagePlus size={15} /> Add image</button>
</div>
- <small>The selected image is sent to VidFab as Picture 1 and anchors the opening frame.</small>
+ <small>The selected image is sent to SlopFab as Picture 1 and anchors the opening frame.</small>
{importError && <small className="scene-settings__error" role="alert">{importError}</small>}
</div>
<label className="scene-settings__field">
diff --git a/src/components/workspace/ShotThumbnail.tsx b/src/components/workspace/ShotThumbnail.tsx
index 9b57039..d88dcb2 100644
--- a/src/components/workspace/ShotThumbnail.tsx
+++ b/src/components/workspace/ShotThumbnail.tsx
@@ -267,7 +267,7 @@ export function ShotThumbnail({ folderPath, job, seconds, endSeconds = sceneDura
/** The next cut (or scene end). Playback never crosses this point. */
endSeconds?: number;
shotNumber: number;
- /** Live rendering estimate derived from vidfab timing; never persisted. */
+ /** Live rendering estimate derived from slopfab timing; never persisted. */
estimatedCompletionAt?: number | null;
/** Cancel was requested but the engine has not reported its terminal state. */
cancelling?: boolean;
diff --git a/src/components/workspace/useGenerationEvents.test.tsx b/src/components/workspace/useGenerationEvents.test.tsx
index d3d3f1a..f0a8813 100644
--- a/src/components/workspace/useGenerationEvents.test.tsx
+++ b/src/components/workspace/useGenerationEvents.test.tsx
@@ -63,7 +63,7 @@ const timingProgress = (jobId: string, updates: Record<string, unknown> = {}) =>
canvasWidth: 416,
canvasHeight: 416,
referenceCount: 0,
- timingProfile: "vidfab=1.4.0|platform=CUDA 13|transformer=test.safetensors",
+ timingProfile: "slopfab=1.4.0|platform=CUDA 13|transformer=test.safetensors",
...updates,
});
@@ -72,7 +72,7 @@ describe("what the app does with the engine's events", () => {
vi.mocked(saveGeneratedScene).mockResolvedValue({ relativePath: "media/generated/job-01.mp4", bytes: 4_200_000, note: null });
const completed = vi.fn();
const { jobId, job, state } = harness(completed);
- await emit("vidfab-job", { jobId, state: "framesReady", detail: "Frames and audio are ready to be encoded." });
+ await emit("slopfab-job", { jobId, state: "framesReady", detail: "Frames and audio are ready to be encoded." });
expect(saveGeneratedScene).toHaveBeenCalledWith(expect.objectContaining({ folderPath: "C:\\Ceramic Lamp", jobId }));
expect(job()).toMatchObject({
@@ -90,7 +90,7 @@ describe("what the app does with the engine's events", () => {
it("keeps the note when something was left out of the file", async () => {
vi.mocked(saveGeneratedScene).mockResolvedValue({ relativePath: "media/generated/job-01.mp4", bytes: 10, note: "Saved without sound: this computer's encoder would not take the render's audio." });
const { jobId, job } = harness();
- await emit("vidfab-job", { jobId, state: "framesReady", detail: "" });
+ await emit("slopfab-job", { jobId, state: "framesReady", detail: "" });
// Finished, with the file — and still saying what is missing from it.
expect(job().status).toBe("completed");
expect(job().error).toMatch(/without sound/);
@@ -111,7 +111,7 @@ describe("what the app does with the engine's events", () => {
return null;
}
render(<Harness />);
- await emit("vidfab-job", { jobId, state: "framesReady", detail: "" });
+ await emit("slopfab-job", { jobId, state: "framesReady", detail: "" });
expect(state.config.assets[0].relativePath).toBe("media/generated/job-initial-brief.mp4");
expect(state.config.timeline.tracks[0].clips[0].status).toBe("generated");
@@ -121,7 +121,7 @@ describe("what the app does with the engine's events", () => {
it("calls a render that could not be written a failure, not a finished scene", async () => {
vi.mocked(saveGeneratedScene).mockRejectedValue(new Error("This computer's encoder refused every H.264 configuration."));
const { jobId, job } = harness();
- await emit("vidfab-job", { jobId, state: "framesReady", detail: "" });
+ await emit("slopfab-job", { jobId, state: "framesReady", detail: "" });
expect(job()).toMatchObject({ status: "failed", stage: "failed" });
expect(job().error).toMatch(/rendered but could not be saved/);
// Nothing to insert into a timeline, and the job must not claim otherwise.
@@ -134,8 +134,8 @@ describe("what the app does with the engine's events", () => {
release = () => resolve({ relativePath: "media/generated/job-01.mp4", bytes: 1, note: null });
}));
const { jobId } = harness();
- await emit("vidfab-job", { jobId, state: "framesReady", detail: "" });
- await emit("vidfab-job", { jobId, state: "framesReady", detail: "" });
+ await emit("slopfab-job", { jobId, state: "framesReady", detail: "" });
+ await emit("slopfab-job", { jobId, state: "framesReady", detail: "" });
expect(saveGeneratedScene).toHaveBeenCalledTimes(1);
await act(async () => { release(); await Promise.resolve(); });
});
@@ -148,7 +148,7 @@ describe("what the app does with the engine's events", () => {
});
const { jobId, job } = harness();
- await emit("vidfab-progress", { jobId, stage: "denoising", step: 25, totalSteps: 50 });
+ await emit("slopfab-progress", { jobId, stage: "denoising", step: 25, totalSteps: 50 });
const rendering = job().progress;
expect(job().status).toBe("generating");
// Rendering never reaches the part of the bar encoding owns, so a finished
@@ -156,49 +156,49 @@ describe("what the app does with the engine's events", () => {
expect(rendering).toBeGreaterThan(0.12);
expect(rendering).toBeLessThan(0.9);
- await emit("vidfab-job", { jobId, state: "framesReady", detail: "" });
+ await emit("slopfab-job", { jobId, state: "framesReady", detail: "" });
await act(async () => { report?.(60, 120); await Promise.resolve(); });
expect(job().status).toBe("completed");
});
it("never rolls overall progress back when a later stage reports a smaller local counter", async () => {
const { jobId, job } = harness();
- await emit("vidfab-progress", { jobId, stage: "denoising", step: 40, totalSteps: 50 });
+ await emit("slopfab-progress", { jobId, stage: "denoising", step: 40, totalSteps: 50 });
const furthest = job().progress;
- await emit("vidfab-progress", { jobId, stage: "audioDecode", step: 0, totalSteps: 0 });
+ await emit("slopfab-progress", { jobId, stage: "audioDecode", step: 0, totalSteps: 0 });
expect(job().progress).toBe(furthest);
expect(job().progress).toBeGreaterThan(0.7);
});
- it("estimates render completion from vidfab elapsed time and completed steps", async () => {
+ it("estimates render completion from slopfab elapsed time and completed steps", async () => {
const onEstimate = vi.fn();
const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
const { jobId } = harness(undefined, onEstimate);
- await emit("vidfab-progress", timingProgress(jobId));
+ await emit("slopfab-progress", timingProgress(jobId));
expect(onEstimate).toHaveBeenLastCalledWith(jobId, null);
now.mockReturnValue(11_000);
- await emit("vidfab-progress", timingProgress(jobId, { step: 1, elapsedSeconds: 30 }));
+ await emit("slopfab-progress", timingProgress(jobId, { step: 1, elapsedSeconds: 30 }));
const completionAt = onEstimate.mock.lastCall?.[1];
// Ten measured seconds per step and two steps remain.
expect(completionAt).toBe(31_000);
vi.mocked(saveGeneratedScene).mockResolvedValue({ relativePath: "media/generated/job-01.mp4", bytes: 1, note: null });
- await emit("vidfab-job", { jobId, state: "framesReady", detail: "" });
+ await emit("slopfab-job", { jobId, state: "framesReady", detail: "" });
expect(onEstimate).toHaveBeenLastCalledWith(jobId, null);
now.mockRestore();
});
it("passes queued, failed and cancelled through as themselves", async () => {
const { jobId, job } = harness();
- await emit("vidfab-job", { jobId, state: "queued", detail: "Queued behind any active vidfab generation." });
+ await emit("slopfab-job", { jobId, state: "queued", detail: "Queued behind any active slopfab generation." });
expect(job()).toMatchObject({ status: "queued", stage: "queued" });
- await emit("vidfab-job", { jobId, state: "failed", detail: "The transformer weights could not be read." });
+ await emit("slopfab-job", { jobId, state: "failed", detail: "The transformer weights could not be read." });
expect(job()).toMatchObject({ status: "failed", stage: "failed", error: "The transformer weights could not be read." });
- await emit("vidfab-job", { jobId, state: "cancelled", detail: "Generation cancelled at the next vidfab checkpoint." });
+ await emit("slopfab-job", { jobId, state: "cancelled", detail: "Generation cancelled at the next slopfab checkpoint." });
expect(job()).toMatchObject({ status: "cancelled", stage: "failed" });
expect(saveGeneratedScene).not.toHaveBeenCalled();
});
@@ -222,7 +222,7 @@ describe("how the hook writes", () => {
return null;
}
render(<Harness />);
- await emit("vidfab-job", { jobId: fresh.generationJobs[0].id, state: "framesReady", detail: "" });
+ await emit("slopfab-job", { jobId: fresh.generationJobs[0].id, state: "framesReady", detail: "" });
expect(writes.length).toBeGreaterThan(0);
expect(writes.every((write) => typeof write === "function")).toBe(true);
// Applied to a config the hook never saw — a project renamed while the
diff --git a/src/components/workspace/useGenerationEvents.ts b/src/components/workspace/useGenerationEvents.ts
index 10a0509..5a7ed23 100644
--- a/src/components/workspace/useGenerationEvents.ts
+++ b/src/components/workspace/useGenerationEvents.ts
@@ -16,7 +16,7 @@ import { generationAssetId, type GenerationJob, type ProjectConfig } from "../..
* screen carries them, so a scene that finishes while the user is somewhere
* else is still recorded and still saved.
*
- * Saving is the second half. vidfab produces pictures and frees them; a finished
+ * Saving is the second half. slopfab produces pictures and frees them; a finished
* render is a few hundred megabytes waiting in Rust's memory that nothing else
* will claim. As soon as the engine says the frames are ready, this encodes
* them (see lib/generatedVideo.ts) and writes the .mp4 into the project. */
@@ -49,7 +49,7 @@ export function useGenerationEvents({ folderPath, onChange, onCompleted, onEstim
* user to click Save. */
onCompleted?: (jobId: string) => void;
/** A transient prediction of when rendering (not file encoding) will finish,
- * based on vidfab's elapsed time and completed steps. It is deliberately
+ * based on slopfab's elapsed time and completed steps. It is deliberately
* kept out of ProjectConfig: an estimate is live UI telemetry, not project
* data worth saving. */
onEstimate?: (jobId: string, completionAt: number | null) => void;
@@ -89,7 +89,7 @@ export function useGenerationEvents({ folderPath, onChange, onCompleted, onEstim
...job,
status: "generating",
stage,
- // vidfab stages do not share one counter. A later stage can report
+ // slopfab stages do not share one counter. A later stage can report
// a smaller local percentage, but overall progress cannot regress.
progress: Math.max(job.progress, progress),
updatedAt: new Date().toISOString(),
@@ -174,7 +174,7 @@ export function useGenerationEvents({ folderPath, onChange, onCompleted, onEstim
};
const subscriptions = Promise.all([
- listen<ProgressEvent>("vidfab-progress", ({ payload }) => {
+ listen<ProgressEvent>("slopfab-progress", ({ payload }) => {
if (disposed) return;
const progress = payload.totalSteps > 0
? Math.min(RENDER_PROGRESS_END, 0.12 + (Math.max(0, payload.step) / payload.totalSteps) * (RENDER_CEILING - 0.14))
@@ -186,7 +186,7 @@ export function useGenerationEvents({ folderPath, onChange, onCompleted, onEstim
payload.stage === "starting" || payload.stage === "transformerLoad" ? "preparing" : "generating",
);
}),
- listen<JobEvent>("vidfab-job", ({ payload }) => {
+ listen<JobEvent>("slopfab-job", ({ payload }) => {
if (disposed) return;
writeDiagnostic(payload.state === "failed" ? "error" : payload.state === "cancelled" ? "warn" : "info", "generation", "native_event.received", payload.detail || `Generation state changed to ${payload.state}.`, {
jobId: payload.jobId, state: payload.state,
diff --git a/src/lib/generatedVideo.test.ts b/src/lib/generatedVideo.test.ts
index 46c78ea..2da7c65 100644
--- a/src/lib/generatedVideo.test.ts
+++ b/src/lib/generatedVideo.test.ts
@@ -186,7 +186,7 @@ describe("generated audio at the Rust/webview boundary", () => {
expect(invoked).toHaveBeenCalledWith("release_generated_frames", { jobId: "job-01" });
});
- it("encodes vidfab's interleaved PCM and adds an AAC track to the saved MP4", async () => {
+ it("encodes slopfab's interleaved PCM and adds an AAC track to the saved MP4", async () => {
desktop();
const audioData: Array<Record<string, unknown>> = [];
diff --git a/src/lib/generatedVideo.ts b/src/lib/generatedVideo.ts
index 652913f..e2021a9 100644
--- a/src/lib/generatedVideo.ts
+++ b/src/lib/generatedVideo.ts
@@ -6,7 +6,7 @@ import { TIMELINE_THUMBNAIL_INTERVAL_MS, writeTimelineThumbnail } from "./timeli
/* Turning a finished render into a file in the project folder.
*
- * vidfab makes pictures, not files: it hands Rust raw frames and raw audio and
+ * slopfab makes pictures, not files: it hands Rust raw frames and raw audio and
* frees them. Encoding is this side's job — WebCodecs owns the machine's
* hardware encoder and PolStudio ships no FFmpeg by design (CLAUDE.md) — so a
* saved scene is a round trip:
@@ -122,7 +122,7 @@ async function renderedFrame(jobId: string, index: number): Promise<Uint8Array>
return bytesFromIpc(await invoke<IpcBytes>("generated_frame", { jobId, index }));
}
-/** Turns the raw IPC body into the interleaved samples vidfab produced. */
+/** Turns the raw IPC body into the interleaved samples slopfab produced. */
export function audioSamplesFromIpc(raw: IpcBytes, expectedSamples: number): Float32Array {
const bytes = bytesFromIpc(raw);
if (bytes.byteLength % Float32Array.BYTES_PER_ELEMENT !== 0) {
@@ -130,7 +130,7 @@ export function audioSamplesFromIpc(raw: IpcBytes, expectedSamples: number): Flo
}
// Copy the exact view. Constructing Float32Array from Uint8Array would turn
// each byte into a sample; constructing it from an offset view can also fail
- // alignment. vidfab and Rust both use native little-endian f32 PCM.
+ // alignment. slopfab and Rust both use native little-endian f32 PCM.
const copy = new Uint8Array(bytes.byteLength);
copy.set(bytes);
const samples = new Float32Array(copy.buffer);
@@ -247,7 +247,7 @@ async function audioConfig(summary: RenderedSummary): Promise<AudioEncoderConfig
return null;
}
-/** Linear PCM resampling is enough here: vidfab's soundtrack is already the
+/** Linear PCM resampling is enough here: slopfab's soundtrack is already the
* final mix, and this only adapts its rate to an AAC configuration the OS
* exposes. Channels remain interleaved throughout. */
export function resampleInterleaved(samples: Float32Array, channels: number, fromRate: number, toRate: number): Float32Array {
@@ -292,7 +292,7 @@ async function encodeAudio(
for (let offset = 0; offset < total; offset += AUDIO_BLOCK) {
if (failure.reason) throw failure.reason;
const count = Math.min(AUDIO_BLOCK, total - offset);
- // vidfab's C API returns [frame0-L, frame0-R, frame1-L, frame1-R, ...].
+ // slopfab's C API returns [frame0-L, frame0-R, frame1-L, frame1-R, ...].
// WebCodecs calls that layout `f32`; `f32-planar` means something else.
const interleaved = prepared.slice(offset * channels, (offset + count) * channels);
const data = new AudioData({
diff --git a/src/lib/generationTiming.test.ts b/src/lib/generationTiming.test.ts
index 56e4ea2..a54a89e 100644
--- a/src/lib/generationTiming.test.ts
+++ b/src/lib/generationTiming.test.ts
@@ -14,7 +14,7 @@ const progress = (updates: Partial<GenerationTimingProgress> = {}): GenerationTi
canvasWidth: 416,
canvasHeight: 416,
referenceCount: 0,
- timingProfile: "vidfab=1.4.0|platform=CUDA 13|transformer=model.safetensors",
+ timingProfile: "slopfab=1.4.0|platform=CUDA 13|transformer=model.safetensors",
...updates,
});
@@ -23,7 +23,7 @@ const completed = (updates: Partial<CompletedGenerationTiming> = {}): CompletedG
width: 416,
height: 416,
referenceCount: 0,
- timingProfile: "vidfab=1.4.0|platform=CUDA 13|transformer=model.safetensors",
+ timingProfile: "slopfab=1.4.0|platform=CUDA 13|transformer=model.safetensors",
secondsConditioning: 5,
secondsDenoise: 40,
secondsVideoDecode: 8,
@@ -34,10 +34,10 @@ const completed = (updates: Partial<CompletedGenerationTiming> = {}): CompletedG
...updates,
});
-describe("vidfab generation timing", () => {
+describe("slopfab generation timing", () => {
beforeEach(() => localStorage.clear());
- it("matches vidfab frame alignment", () => {
+ it("matches slopfab frame alignment", () => {
expect(alignedGenerationFrames(5)).toBe(5);
expect(alignedGenerationFrames(360)).toBe(362);
});
diff --git a/src/lib/generationTiming.ts b/src/lib/generationTiming.ts
index e95818a..134ed25 100644
--- a/src/lib/generationTiming.ts
+++ b/src/lib/generationTiming.ts
@@ -1,7 +1,7 @@
/**
* Stage-aware generation timing.
*
- * vidfab reports elapsed wall time and completed denoising steps while a run
+ * slopfab reports elapsed wall time and completed denoising steps while a run
* is active, then returns the measured duration of each expensive stage. The
* live samples give an honest seconds-per-step rate; successful runs supply a
* small machine-local calibration for the work before and after denoising.
@@ -63,7 +63,7 @@ type TimingStorage = Pick<Storage, "getItem" | "setItem">;
const finiteNonNegative = (value: number) => Number.isFinite(value) && value >= 0;
-/** The frame alignment used by vidfab's resolved plan: 17*k + 5. */
+/** The frame alignment used by slopfab's resolved plan: 17*k + 5. */
export function alignedGenerationFrames(frames: number): number {
return Math.ceil((Math.max(5, Math.round(frames)) - 5) / 17) * 17 + 5;
}
diff --git a/src/lib/project.test.ts b/src/lib/project.test.ts
index 303893a..c972788 100644
--- a/src/lib/project.test.ts
+++ b/src/lib/project.test.ts
@@ -237,7 +237,7 @@ describe("project schema", () => {
});
it("numbers <Picture N> in the order the engine consumes reference_paths", () => {
- // vidfab.rs iterates reference_paths sequentially, so index 0 is <Picture 1>.
+ // slopfab.rs iterates reference_paths sequentially, so index 0 is <Picture 1>.
const img = (id: string, name: string, path: string): ProjectReference => projectReferenceSchema.parse({
id, kind: "image", name, description: "A reference.", relativePath: path,
intendedUse: ["style"], createdAt: new Date().toISOString(),
@@ -333,7 +333,7 @@ describe("project schema", () => {
it("drops an audio-tagged image from both the prompt and reference_paths together", () => {
// The two filters must agree: GeneratorView builds referencePaths from
// usableImageReferences while the prompt numbers <Picture N> from the
- // compiler's list, and vidfab.rs consumes the array positionally.
+ // compiler's list, and slopfab.rs consumes the array positionally.
const audioImage = imageReference({ id: "img-audio", name: "Waveform note", relativePath: "references/waveform.png", intendedUse: ["audio"] });
const visualImage = imageReference({ id: "img-visual", name: "Harbor facade", relativePath: "references/harbor.jpg", intendedUse: ["location"] });
const references = [audioImage, visualImage];
@@ -513,7 +513,7 @@ describe("project schema", () => {
});
it("resolves project-relative reference paths to absolute for the engine", () => {
- // enqueue_vidfab_generation never receives the project folder and vidfab.rs
+ // enqueue_slopfab_generation never receives the project folder and slopfab.rs
// uses the string verbatim, so the frontend must send an absolute path.
expect(projectFilePath("C:\\Projects\\Lighthouse", "references/a.jpg")).toBe("C:\\Projects\\Lighthouse\\references\\a.jpg");
expect(projectFilePath("/home/nn/lighthouse", "references/a.jpg")).toBe("/home/nn/lighthouse/references/a.jpg");
diff --git a/src/lib/project.ts b/src/lib/project.ts
index 3082719..4fd3d81 100644
--- a/src/lib/project.ts
+++ b/src/lib/project.ts
@@ -8,7 +8,7 @@ export const PROJECT_FILE_NAME = "polstudio.json";
export const LEGACY_PROJECT_FILE_NAMES = ["pols.json", "polstudio.project.json"] as const;
export const CURRENT_SCHEMA_VERSION = 1 as const;
export const DEFAULT_GENERATION_STEPS = 20;
-/** Vidfab's native generation clock. Project frame rate is an editing/export
+/** Slopfab's native generation clock. Project frame rate is an editing/export
* target; higher rates are produced later by interpolation and retiming. */
export const GENERATION_FRAME_RATE = 24;
export const MAX_GENERATION_STEPS = 2_147_483_647;
@@ -553,8 +553,8 @@ export interface CreateProjectInput {
}
/** Absolute on-disk path for a project-relative file.
- * The generation backend uses `reference_paths` verbatim (vidfab.rs:339 calls
- * Path::new on each string) and enqueue_vidfab_generation is never told the
+ * The generation backend uses `reference_paths` verbatim (slopfab.rs:339 calls
+ * Path::new on each string) and enqueue_slopfab_generation is never told the
* project folder, so a relative path would resolve against the process working
* directory. Callers must resolve to absolute before sending. */
export function projectFilePath(folderPath: string, relativePath: string): string {
@@ -708,7 +708,7 @@ const referenceLabel = (reference: ProjectReference, index: number) => `<Subject
/** Image references are the only ones that can be sent to the engine as assets,
* so they carry the <Picture N> numbering. That numbering MUST match the order
- * of `reference_paths` in the generation request: vidfab.rs iterates the array
+ * of `reference_paths` in the generation request: slopfab.rs iterates the array
* and calls add_reference sequentially, so index 0 is <Picture 1>.
*
* The filter pair below is therefore load-bearing and must stay identical to
@@ -722,13 +722,13 @@ export function usableImageReferences(references: ProjectReference[]): ProjectRe
.filter(isVisualReference);
}
-/** Image payloads in exactly the order VidFab receives them. Multiple images
+/** Image payloads in exactly the order SlopFab receives them. Multiple images
* on one reference stay adjacent and share that reference's subject. */
export function usableReferenceImages(references: ProjectReference[]): ProjectReferenceImage[] {
return usableImageReferences(references).flatMap(referenceImages);
}
-/** References in the exact order both the prompt compiler and VidFab consume.
+/** References in the exact order both the prompt compiler and SlopFab consume.
* A start frame must be Picture 1; ordinary bound references retain project
* order after it and a frame that is also bound is still sent only once. */
export function sceneGenerationReferences(job: GenerationJob, references: ProjectReference[]): ProjectReference[] {
diff --git a/src/lib/runtime.test.ts b/src/lib/runtime.test.ts
index 995037f..537bcd5 100644
--- a/src/lib/runtime.test.ts
+++ b/src/lib/runtime.test.ts
@@ -2,7 +2,7 @@
import { beforeEach, describe, expect, it } from "vitest";
import { compileGenerationJobPrompt, createProjectConfig } from "./project";
-import { executeAgentCommands, getRuntimeStatus, resolveVidfabPlan, runAgentTurn } from "./runtime";
+import { executeAgentCommands, getRuntimeStatus, resolveSlopfabPlan, runAgentTurn } from "./runtime";
const project = () => ({
folderPath: "~/PolStudio/runtime-test",
@@ -21,8 +21,8 @@ describe("deterministic browser runtime", () => {
it("reports explicit demo status and a plan-only generation boundary", async () => {
const record = project();
const status = await getRuntimeStatus();
- expect(status.vidfab.state).toBe("demo");
- const plan = await resolveVidfabPlan({
+ expect(status.slopfab.state).toBe("demo");
+ const plan = await resolveSlopfabPlan({
jobId: "job-plan", prompt: "three field prompt", frames: 180, steps: 50,
seed: 1, canvasWidth: 1920, canvasHeight: 1088, referencePaths: [],
}, record.config);
diff --git a/src/lib/runtime.ts b/src/lib/runtime.ts
index c772f8b..6606be7 100644
--- a/src/lib/runtime.ts
+++ b/src/lib/runtime.ts
@@ -25,7 +25,7 @@ export interface ProviderStatus {
detail: string;
}
export interface ModelStatus { id: string; configured: boolean; available: boolean; path: string | null }
-export interface VidfabStatus {
+export interface SlopfabStatus {
state: "ready" | "modelsMissing" | "runtimeMissing" | "incompatible" | "demo";
dllPath: string;
version: string | null;
@@ -33,7 +33,7 @@ export interface VidfabStatus {
detail: string;
models: ModelStatus[];
}
-export interface RuntimeStatus { providers: ProviderStatus[]; vidfab: VidfabStatus }
+export interface RuntimeStatus { providers: ProviderStatus[]; slopfab: SlopfabStatus }
export type ProjectCommand =
| { op: "project.set"; name?: string; prompt?: string; targetSeconds?: number; aspectRatio?: string; resolution?: string; frameRate?: number; backgroundColor?: string }
@@ -75,7 +75,7 @@ export interface AgentTurnResponse {
messages: AgentMessage[];
}
-export interface VidfabGenerationRequest {
+export interface SlopfabGenerationRequest {
jobId: string;
prompt: string;
frames: number;
@@ -105,10 +105,10 @@ const DEMO_STATUS: RuntimeStatus = {
{ id: "claude", label: "Claude Code", state: "ready", executable: null, version: "Browser demo", detail: "Deterministic local demo provider." },
{ id: "codex", label: "Codex", state: "ready", executable: null, version: "Browser demo", detail: "Deterministic local demo provider." },
],
- vidfab: { state: "demo", dllPath: "Browser demo", version: null, platform: null, detail: "Deterministic plans only. No model runs or media files are created in the browser.", models: [] },
+ slopfab: { state: "demo", dllPath: "Browser demo", version: null, platform: null, detail: "Deterministic plans only. No model runs or media files are created in the browser.", models: [] },
};
-/* Every vidfab command is handed the project config with THIS machine's engine
+/* Every slopfab command is handed the project config with THIS machine's engine
paths merged in (see lib/settings.ts). The merged copy is passed straight to
the command and dropped; it is never the config that gets saved. */
@@ -118,7 +118,7 @@ const DEMO_STATUS: RuntimeStatus = {
export async function getRuntimeStatus(): Promise<RuntimeStatus> {
if (!isTauri()) return DEMO_STATUS;
return invoke<RuntimeStatus>("runtime_status", {
- settings: { vidfab: engineProviderSetting(loadEngineSettings()), ...agentEndpointProviderSettings() },
+ settings: { slopfab: engineProviderSetting(loadEngineSettings()), ...agentEndpointProviderSettings() },
});
}
@@ -130,9 +130,9 @@ export const CHECKING_PROVIDERS: ProviderStatus[] = [
/** Probes the engine paths on their own, with no project in hand — what the
* settings screen shows. */
-export async function getEngineStatus(settings = loadEngineSettings()): Promise<VidfabStatus> {
- if (!isTauri()) return DEMO_STATUS.vidfab;
- return invoke<VidfabStatus>("vidfab_status", { settings: { vidfab: engineProviderSetting(settings) } });
+export async function getEngineStatus(settings = loadEngineSettings()): Promise<SlopfabStatus> {
+ if (!isTauri()) return DEMO_STATUS.slopfab;
+ return invoke<SlopfabStatus>("slopfab_status", { settings: { slopfab: engineProviderSetting(settings) } });
}
/** Opens the OS picker for one engine path. Returns null when the user cancels. */
@@ -197,8 +197,8 @@ export async function cancelAgentTurn(requestId: string): Promise<boolean> {
return isTauri() ? invoke<boolean>("cancel_agent_turn", { requestId }) : true;
}
-export async function resolveVidfabPlan(request: VidfabGenerationRequest, config: ProjectConfig): Promise<ResolvedPlan> {
- if (isTauri()) return invoke<ResolvedPlan>("resolve_vidfab_plan", { request, config: withEngineSettings(config) });
+export async function resolveSlopfabPlan(request: SlopfabGenerationRequest, config: ProjectConfig): Promise<ResolvedPlan> {
+ if (isTauri()) return invoke<ResolvedPlan>("resolve_slopfab_plan", { request, config: withEngineSettings(config) });
const alignedFrames = Math.ceil(Math.max(5, request.frames - 5) / 17) * 17 + 5;
return {
canvasWidth: request.canvasWidth,
@@ -213,12 +213,12 @@ export async function resolveVidfabPlan(request: VidfabGenerationRequest, config
};
}
-export async function enqueueVidfabGeneration(request: VidfabGenerationRequest, config: ProjectConfig): Promise<void> {
- if (isTauri()) await invoke("enqueue_vidfab_generation", { request, config: withEngineSettings(config) });
+export async function enqueueSlopfabGeneration(request: SlopfabGenerationRequest, config: ProjectConfig): Promise<void> {
+ if (isTauri()) await invoke("enqueue_slopfab_generation", { request, config: withEngineSettings(config) });
}
-export async function cancelVidfabGeneration(jobId: string): Promise<boolean> {
- return isTauri() ? invoke<boolean>("cancel_vidfab_generation", { jobId }) : true;
+export async function cancelSlopfabGeneration(jobId: string): Promise<boolean> {
+ return isTauri() ? invoke<boolean>("cancel_slopfab_generation", { jobId }) : true;
}
function demoTurn(_config: ProjectConfig, prompt: string): AgentTurnResult {
diff --git a/src/lib/settings.ts b/src/lib/settings.ts
index afab8bf..3a0f7a6 100644
--- a/src/lib/settings.ts
+++ b/src/lib/settings.ts
@@ -3,13 +3,13 @@
* The video engine and its weights are a property of THIS computer, not of a
* project: a project folder copied from another machine carries paths that do
* not exist here. They therefore live in localStorage rather than in
- * polstudio.json, and are merged into `providerSettings.vidfab` only
+ * polstudio.json, and are merged into `providerSettings.slopfab` only
* on the way into a Tauri command — never on the way into a saved config.
* Keep it that way: writing them into a project file would put one machine's
* disk layout into a file the user is invited to move, copy, and share.
*
* The option names below are the contract with `Configuration::from_settings`
- * in src-tauri/src/vidfab.rs. Renaming one here without renaming it there
+ * in src-tauri/src/slopfab.rs. Renaming one here without renaming it there
* silently drops that path.
*/
import { DEFAULT_GENERATION_STEPS, MAX_GENERATION_STEPS, type ProjectConfig, type ProviderSetting } from "./project";
@@ -173,7 +173,7 @@ export function saveEngineSettings(settings: EngineSettings): void {
});
}
-/** The `vidfab` provider setting these paths describe, with blanks dropped so
+/** The `slopfab` provider setting these paths describe, with blanks dropped so
* an unset field falls through to whatever the project (or the Rust default)
* already had rather than overwriting it with "". */
export function engineProviderSetting(settings: EngineSettings, base?: ProviderSetting): ProviderSetting {
@@ -192,7 +192,7 @@ export function withEngineSettings(config: ProjectConfig): ProjectConfig {
...config,
providerSettings: {
...config.providerSettings,
- vidfab: engineProviderSetting(loadEngineSettings(), config.providerSettings.vidfab),
+ slopfab: engineProviderSetting(loadEngineSettings(), config.providerSettings.slopfab),
},
};
}