Skip to content

AI media harness for planning, generating, and editing locally

TypeScript

Store and restore image generation snapshots

Bittiaa419ff4bee2
diff --git a/docs/architecture.md b/docs/architecture.md
index 1b3ddb3..ae58da4 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -47,6 +47,8 @@ Image projects retain the [H3 base prompt structure](https://huggingface.co/Mini
## Generation boundary
+Each newly generated image asset stores an optional `imageGeneration` snapshot captured when the job is queued: the authored image tree, background and style, seed and steps, resolution and aspect ratio, project look, brief, selected reference definitions and attachments, generator template ID, and exact submitted prompt. Completion attaches that snapshot without replacing edits made during generation. Selecting the result restores a copy of its inputs and merges its saved references into the library; other results and unrelated references remain available. The native project schema validates and preserves snapshots on save and reopen. Older images without a snapshot retain the current authoring state when selected.
+
The slopfab C API is loaded dynamically by the Rust backend. It resolves requests immediately, runs asynchronously, permits only one active generation per process, reports progress from a worker thread, and returns raw planar RGB frames plus interleaved audio. Slopus therefore owns:
- compute-platform selection: CUDA 13 when usable, then CUDA 12, then Vulkan with exact attention;
diff --git a/fixtures/image-generation-snapshot.json b/fixtures/image-generation-snapshot.json
new file mode 100644
index 0000000..80d9904
--- /dev/null
+++ b/fixtures/image-generation-snapshot.json
@@ -0,0 +1,26 @@
+{
+ "scene": {
+ "nodes": [
+ { "id": "image-root", "parentId": null, "kind": "root", "name": "Image", "description": "A lantern above a quiet lake", "text": "", "box": null, "colors": ["#204060"] },
+ { "id": "lantern", "parentId": "image-root", "kind": "group", "name": "Lantern", "description": "A red paper lantern", "text": "", "box": { "x": 200, "y": 100, "width": 400, "height": 600 }, "colors": [] },
+ { "id": "lettering", "parentId": "lantern", "kind": "text", "name": "Lettering", "description": "Gold lettering", "text": "静かな夜", "box": { "x": 250, "y": 200, "width": 200, "height": 100 }, "colors": ["#FFD700"] }
+ ],
+ "background": "A moonlit lake",
+ "style": { "mode": "art", "aesthetics": "serene", "lighting": "moonlight", "medium": "Watercolor", "detail": "Ink outlines" },
+ "steps": 30,
+ "seed": 42,
+ "referenceIds": ["lantern-style"],
+ "outputAssetId": null
+ },
+ "resolution": "1088p",
+ "aspectRatio": "4:5",
+ "defaultLook": "watercolor",
+ "briefPrompt": "A lantern above a quiet lake",
+ "prompt": "detailed_description: A watercolor still image. [Shot 1] A lantern above a quiet lake.",
+ "generatorTemplateId": "lantern-generator",
+ "references": [
+ { "id": "lantern-style", "name": "Lantern style", "kind": "text", "description": "Red paper with golden lettering", "intendedUse": ["style"], "createdAt": "2026-01-01T00:00:00.000Z", "refmods": [
+ { "id": "style-refmod", "name": "Lantern style", "relativePath": "references/lantern.safetensors", "strength": 0.75, "copies": 2 }
+ ] }
+ ]
+}
diff --git a/src-tauri/src/project/commands/clips.rs b/src-tauri/src/project/commands/clips.rs
index 2931d40..91692fc 100644
--- a/src-tauri/src/project/commands/clips.rs
+++ b/src-tauri/src/project/commands/clips.rs
@@ -61,6 +61,7 @@ pub(super) fn apply(
width: None,
height: None,
has_audio: None,
+ image_generation: None,
created_at: job.created_at.clone(),
});
planned_id
diff --git a/src-tauri/src/project/image.rs b/src-tauri/src/project/image.rs
index 4664a4f..b3810df 100644
--- a/src-tauri/src/project/image.rs
+++ b/src-tauri/src/project/image.rs
@@ -1,6 +1,19 @@
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub(crate) struct ImageGenerationSnapshot {
+ pub scene: ImageScene,
+ pub resolution: String,
+ pub aspect_ratio: String,
+ pub default_look: Option<String>,
+ pub brief_prompt: String,
+ pub prompt: String,
+ pub generator_template_id: String,
+ pub references: Vec<super::references::ReusableReference>,
+}
+
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ImageScene {
diff --git a/src-tauri/src/project/model.rs b/src-tauri/src/project/model.rs
index a0b1f43..4feb7fa 100644
--- a/src-tauri/src/project/model.rs
+++ b/src-tauri/src/project/model.rs
@@ -93,6 +93,8 @@ pub(crate) struct ProjectAsset {
pub(crate) height: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub(crate) has_audio: Option<bool>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub(crate) image_generation: Option<super::image::ImageGenerationSnapshot>,
pub(crate) created_at: String,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
diff --git a/src-tauri/src/project/validation/assets.rs b/src-tauri/src/project/validation/assets.rs
index 6128aa3..236332c 100644
--- a/src-tauri/src/project/validation/assets.rs
+++ b/src-tauri/src/project/validation/assets.rs
@@ -3,6 +3,23 @@ use crate::project::paths::*;
use crate::project::*;
pub(super) fn validate(config: &mut ProjectConfig) -> Result<(), String> {
for asset in &mut config.assets {
+ if let Some(snapshot) = &mut asset.image_generation {
+ snapshot.scene.validate()?;
+ if asset.kind != "image"
+ || !is_supported_resolution(&snapshot.resolution)
+ || !is_supported_aspect_ratio(&snapshot.aspect_ratio)
+ || snapshot.default_look.as_deref().is_some_and(|look| !is_shot_tag_id(look))
+ || snapshot.generator_template_id.is_empty()
+ || snapshot.references.len() > 100
+ {
+ return Err("Invalid image generation snapshot settings.".into());
+ }
+ super::references::validate_references(&mut snapshot.references)?;
+ let ids = unique_ids(snapshot.references.iter().map(|reference| reference.id.as_str()), "image snapshot reference")?;
+ if snapshot.scene.reference_ids.iter().any(|id| !ids.contains(id.as_str())) {
+ return Err("Image generation snapshot has a missing reference.".into());
+ }
+ }
if asset.id.trim().is_empty() || asset.name.trim().is_empty() {
return Err("Asset id and name cannot be empty.".into());
}
diff --git a/src-tauri/src/project/validation/references.rs b/src-tauri/src/project/validation/references.rs
index 0c7e3df..60e07dc 100644
--- a/src-tauri/src/project/validation/references.rs
+++ b/src-tauri/src/project/validation/references.rs
@@ -3,7 +3,10 @@ use crate::project::paths::*;
use crate::project::*;
use std::collections::BTreeSet;
pub(super) fn validate(config: &mut ProjectConfig) -> Result<(), String> {
- for reference in &mut config.references {
+ validate_references(&mut config.references)
+}
+pub(super) fn validate_references(references: &mut [ReusableReference]) -> Result<(), String> {
+ for reference in references {
if reference.id.trim().is_empty() || reference.name.trim().is_empty() {
return Err("Reference id and name cannot be empty.".into());
}
diff --git a/src-tauri/src/tests/images.rs b/src-tauri/src/tests/images.rs
index a1a3081..2428ccd 100644
--- a/src-tauri/src/tests/images.rs
+++ b/src-tauri/src/tests/images.rs
@@ -73,6 +73,38 @@ fn image_tree_survives_folder_creation_save_and_reopen() {
assert_eq!(roundtrip.image_scene, config.image_scene);
}
+#[test]
+fn image_generation_history_survives_native_save_and_reopen_and_validates_snapshots() {
+ let snapshot: serde_json::Value = serde_json::from_str(include_str!("../../../fixtures/image-generation-snapshot.json")).unwrap();
+ let expected: crate::project::image::ImageGenerationSnapshot = serde_json::from_value(snapshot.clone()).unwrap();
+ let mut config = image_fixture();
+ config.assets.push(serde_json::from_value(serde_json::json!({
+ "id": "image-history", "kind": "image", "name": "Lantern", "relativePath": "media/generated/lantern.jpg",
+ "mimeType": "image/jpeg", "width": 1088, "height": 1344, "createdAt": config.created_at,
+ "imageGeneration": snapshot,
+ })).unwrap());
+ let root = tempfile::tempdir().unwrap();
+ let created = create_project_in(root.path(), &config).unwrap();
+ let opened = read_project(Path::new(&created.folder_path)).unwrap();
+ assert_eq!(opened.config.assets[0].image_generation.as_ref(), Some(&expected));
+ let mut updated = opened.config;
+ updated.image_scene.as_mut().unwrap().background = "Changed since generation".into();
+ updated.references.clear();
+ write_project(Path::new(&created.folder_path), &updated).unwrap();
+ let reopened = read_project(Path::new(&created.folder_path)).unwrap();
+ assert_eq!(reopened.config.assets[0].image_generation.as_ref(), Some(&expected));
+ for invalid in ["tree", "reference", "resolution"] {
+ let mut bad = reopened.config.clone();
+ let history = bad.assets[0].image_generation.as_mut().unwrap();
+ match invalid {
+ "tree" => history.scene.nodes[1].parent_id = Some("missing".into()),
+ "reference" => history.references.clear(),
+ _ => history.resolution = "invalid".into(),
+ }
+ assert!(validate_and_normalize_config(bad).is_err(), "{invalid}");
+ }
+}
+
#[test]
fn invalid_image_hierarchies_and_bounds_are_rejected() {
for invalid in ["cycle", "missing", "duplicate", "disconnected", "bounds"] {
diff --git a/src-tauri/src/tests/media_access.rs b/src-tauri/src/tests/media_access.rs
index 395d52a..7de5c8b 100644
--- a/src-tauri/src/tests/media_access.rs
+++ b/src-tauri/src/tests/media_access.rs
@@ -111,6 +111,7 @@ fn external_media_is_readable_only_because_the_project_names_it() {
width: None,
height: None,
has_audio: None,
+ image_generation: None,
created_at: config.created_at.clone(),
});
let created = create_project_in(root.path(), &config).unwrap();
@@ -282,6 +283,7 @@ fn a_project_the_user_only_opened_reads_any_media_file_it_names() {
width: None,
height: None,
has_audio: None,
+ image_generation: None,
created_at: config.created_at.clone(),
});
}
diff --git a/src-tauri/src/tests/persistence.rs b/src-tauri/src/tests/persistence.rs
index 9df5365..8e9cfa2 100644
--- a/src-tauri/src/tests/persistence.rs
+++ b/src-tauri/src/tests/persistence.rs
@@ -351,6 +351,7 @@ fn a_project_file_only_yields_media_a_hand_edit_cannot_widen() {
width: None,
height: None,
has_audio: None,
+ image_generation: None,
created_at: config.created_at.clone(),
});
let created = create_project_in(root.path(), &config).unwrap();
diff --git a/src/components/workspace/ImageEditor.test.tsx b/src/components/workspace/ImageEditor.test.tsx
index 8e9ae36..d4f4eb9 100644
--- a/src/components/workspace/ImageEditor.test.tsx
+++ b/src/components/workspace/ImageEditor.test.tsx
@@ -4,9 +4,12 @@ import { useState } from "react";
import { cleanup, createEvent, fireEvent, render, screen, within } from "@testing-library/react";
import { afterEach, expect, it, vi } from "vitest";
import { ImageEditor } from "./ImageEditor";
-import { parseProjectConfig, type ProjectConfig } from "../../lib/project";
+import { imageGenerationSnapshotSchema, parseProjectConfig, type ProjectConfig } from "../../lib/project";
+import { imageGenerationSnapshot } from "../../lib/imageHistory";
+import { defaultGeneratorTemplate, saveGeneratorTemplateSettings } from "../../lib/settings";
import { imageScenePrompt } from "../../lib/imageScene";
import fixture from "../../../fixtures/project-v1-image.json";
+import snapshotFixture from "../../../fixtures/image-generation-snapshot.json";
afterEach(() => { cleanup(); localStorage.clear(); });
function setup(initial = parseProjectConfig(fixture)) {
@@ -20,6 +23,34 @@ function setup(initial = parseProjectConfig(fixture)) {
return () => latest;
}
+it("restores the hierarchy, prompts, settings and generator when selecting a saved result", () => {
+ const initial = parseProjectConfig(fixture);
+ const original = imageGenerationSnapshot(initial, "Original prompt", defaultGeneratorTemplate().id);
+ const saved = imageGenerationSnapshotSchema.parse(snapshotFixture);
+ saveGeneratorTemplateSettings({ defaultTemplateId: original.generatorTemplateId, templates: [defaultGeneratorTemplate(), { ...defaultGeneratorTemplate(), id: saved.generatorTemplateId, name: "Lantern generator" }] });
+ initial.assets = [original, saved].map((snapshot, index) => ({ id: `result-${index}`, name: `Result ${index}`, kind: "image", relativePath: `media/generated/result-${index}.jpg`, mimeType: "image/jpeg", createdAt: initial.createdAt, imageGeneration: snapshot }));
+ initial.imageScene!.outputAssetId = "result-0";
+ const current = setup(initial);
+ fireEvent.change(screen.getByLabelText("Prompt (high-level description)"), { target: { value: "Unsaved edit" } });
+ expect(screen.getByRole("button", { name: "Undo image edit" })).toBeEnabled();
+ fireEvent.click(screen.getByRole("button", { name: "View Result 1" }));
+ expect(screen.getByLabelText("Prompt (high-level description)")).toHaveValue(saved.scene.nodes[0].description);
+ expect(screen.getByLabelText("Steps")).toHaveValue(30);
+ expect(screen.getByLabelText("Generator")).toHaveValue(saved.generatorTemplateId);
+ expect(screen.getByRole("button", { name: "Lantern" })).toBeInTheDocument();
+ expect(screen.getByRole("button", { name: "Lettering" })).toBeInTheDocument();
+ expect(current().references).toEqual(saved.references);
+ expect(current().settings).toMatchObject({ resolution: "1088p", aspectRatio: "4:5" });
+ expect(screen.getByRole("button", { name: "Undo image edit" })).toBeDisabled();
+ fireEvent.change(screen.getByLabelText("Prompt (high-level description)"), { target: { value: "Another edit" } });
+ fireEvent.click(screen.getByRole("button", { name: "View Result 0" }));
+ expect(current().imageScene).toEqual({ ...original.scene, outputAssetId: "result-0" });
+ expect(screen.getByLabelText("Generator")).toHaveValue(original.generatorTemplateId);
+ fireEvent.click(screen.getByRole("button", { name: "View Result 1" }));
+ expect(current().imageScene).toEqual({ ...saved.scene, outputAssetId: "result-1" });
+ expect(current().assets[1].imageGeneration).toEqual(saved);
+});
+
it("displays each generated image at its saved aspect ratio independently of future generation settings", () => {
const initial = parseProjectConfig(fixture);
initial.assets = [
diff --git a/src/components/workspace/ImageEditor.tsx b/src/components/workspace/ImageEditor.tsx
index 37903c8..56cc2af 100644
--- a/src/components/workspace/ImageEditor.tsx
+++ b/src/components/workspace/ImageEditor.tsx
@@ -3,6 +3,7 @@ import { Box, ChevronDown, ChevronRight, ClipboardPaste, Copy, FolderPlus, Image
import { addImageNode, createImageScene, duplicateImageNode, imageDescendants, imageScenePrompt, removeImageNode, resizeImageNode, type ImageBox, type ImageNode, type ImageScene } from "../../lib/imageScene";
import { outputDimensions } from "../../lib/export";
import { compileImagePrompt } from "../../lib/imagePrompt";
+import { restoreGeneratedImage } from "../../lib/imageHistory";
import { isTauri } from "../../lib/persistence";
import { PROJECT_RESOLUTIONS, type ProjectConfig } from "../../lib/project";
import { defaultGeneratorTemplate, loadDebugOptionsEnabled, loadGeneratorTemplateSettings, subscribeDebugOptions, subscribeGeneratorTemplates, templateNeedsDownload, type GeneratorTemplate } from "../../lib/settings";
@@ -142,6 +143,21 @@ export function ImageEditor({ config, folderPath, onChange, onGenerate, onCancel
const button = [...(imageResults.current?.querySelectorAll<HTMLButtonElement>("button") ?? [])].find((element) => element.dataset.imageAsset === imageMenu?.id);
setImageMenu(null); button?.focus();
};
+ const resetImageEditing = (id: string) => {
+ const snapshot = config.assets.find((asset) => asset.id === id)?.imageGeneration;
+ if (!snapshot) return;
+ undo.current = []; redo.current = []; historyChanged((value) => value + 1);
+ pointer.current = null; setDraftBox(null); setDrawKind(null); setRenaming(null);
+ setCollapsed(new Set()); setSelection(snapshot.scene.nodes.find((node) => node.kind === "root")!.id);
+ if (imageTemplates.some((candidate) => candidate.id === snapshot.generatorTemplateId)) {
+ setTemplateId(snapshot.generatorTemplateId);
+ localStorage.setItem("slopus.image-generator-template.v1", snapshot.generatorTemplateId);
+ }
+ };
+ const selectImage = (id: string) => {
+ resetImageEditing(id);
+ onChange((current) => restoreGeneratedImage(current, id));
+ };
const removeImage = (id: string) => {
onChange((current) => {
const removed = current.assets.find((asset) => asset.id === id && asset.kind === "image");
@@ -153,14 +169,19 @@ export function ImageEditor({ config, folderPath, onChange, onGenerate, onCancel
const next = removingSelected
? remaining[Math.min(currentImages.findIndex((asset) => asset.id === id), remaining.length - 1)]
: remaining.find((asset) => asset.id === currentScene.outputAssetId);
- return { ...current,
+ const updated = { ...current,
assets: current.assets.filter((asset) => asset.id !== id),
imageScene: { ...currentScene, outputAssetId: removingSelected ? next?.id ?? null : currentScene.outputAssetId },
thumbnail: removingSelected || current.thumbnail === removed.relativePath ? next?.relativePath ?? null : current.thumbnail,
timeline: { ...current.timeline, tracks: current.timeline.tracks.map((track) => ({ ...track, clips: track.clips.filter((clip) => clip.assetId !== id) })) },
};
+ return removingSelected && next ? restoreGeneratedImage(updated, next.id) : updated;
+ });
+ requestAnimationFrame(() => {
+ const selectedButton = imageResults.current?.querySelector<HTMLButtonElement>('button[aria-pressed="true"]');
+ if (scene.outputAssetId === id && selectedButton?.dataset.imageAsset) resetImageEditing(selectedButton.dataset.imageAsset);
+ (selectedButton ?? imageResults.current?.querySelector<HTMLButtonElement>("button") ?? viewport.current)?.focus();
});
- requestAnimationFrame(() => (imageResults.current?.querySelector<HTMLButtonElement>('button[aria-pressed="true"]') ?? imageResults.current?.querySelector<HTMLButtonElement>("button") ?? viewport.current)?.focus());
};
const startRename = () => { renameEnding.current = false; setRenaming({ id: selected.id, value: selected.name }); };
const finishRename = (save: boolean, restoreFocus = true) => {
@@ -357,7 +378,7 @@ export function ImageEditor({ config, folderPath, onChange, onGenerate, onCancel
setContextMenu(null); setImageMenu({ id: asset.id, x: bounds.left, y: bounds.bottom });
}
}}
- onClick={() => onChange((current) => ({ ...current, thumbnail: asset.relativePath ?? null, imageScene: { ...(current.imageScene ?? scene), outputAssetId: asset.id } }))}><ReferenceImage folderPath={folderPath} relativePath={asset.relativePath} sourcePath={asset.sourcePath} alt={asset.name} /></button>)}</div>}
+ onClick={() => selectImage(asset.id)}><ReferenceImage folderPath={folderPath} relativePath={asset.relativePath} sourcePath={asset.sourcePath} alt={asset.name} /></button>)}</div>}
</section>
<aside className="image-inspector" aria-label="Image node inspector"><header><strong>Inspector</strong><span>{selected.kind}</span></header><div className="image-inspector__fields">
<label>Name<input value={selected.name} maxLength={120} onChange={(event) => { if (event.target.value.trim()) patchNode({ name: event.target.value }); }} /></label>
diff --git a/src/lib/imageHistory.test.ts b/src/lib/imageHistory.test.ts
new file mode 100644
index 0000000..dbf9b1e
--- /dev/null
+++ b/src/lib/imageHistory.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { imageGenerationSnapshot, restoreGeneratedImage } from "./imageHistory";
+import { imageGenerationSnapshotSchema, parseProjectConfig } from "./project";
+import fixture from "../../fixtures/project-v1-image.json";
+import snapshotFixture from "../../fixtures/image-generation-snapshot.json";
+
+describe("generated image history", () => {
+ it("restores saved inputs and references after reopening without changing other results", () => {
+ const config = parseProjectConfig(fixture);
+ const snapshot = imageGenerationSnapshotSchema.parse(snapshotFixture);
+ config.assets = [{ id: "result", kind: "image", name: "Lantern", relativePath: "media/generated/lantern.jpg", mimeType: "image/jpeg", createdAt: config.createdAt, imageGeneration: snapshot }];
+ config.references = [
+ { ...snapshot.references[0], description: "Later reference edit" },
+ { id: "unrelated", name: "Unrelated", kind: "text", description: "Keep this", intendedUse: [], createdAt: config.createdAt },
+ ];
+ const reopened = parseProjectConfig(JSON.parse(JSON.stringify(config)));
+ const restored = restoreGeneratedImage(reopened, "result");
+ expect(restored.imageScene).toEqual({ ...snapshot.scene, outputAssetId: "result" });
+ expect(restored.settings).toMatchObject({ resolution: "1088p", aspectRatio: "4:5", defaultLook: "watercolor" });
+ expect(restored.brief.prompt).toBe(snapshot.briefPrompt);
+ expect(restored.references).toEqual([snapshot.references[0], config.references[1]]);
+ expect(restored.assets).toEqual(config.assets);
+ restored.imageScene!.nodes[0].description = "New edit";
+ restored.references[0].refmods![0].strength = 0;
+ expect(restored.assets[0].imageGeneration).toEqual(snapshotFixture);
+ reopened.references = [];
+ expect(restoreGeneratedImage(reopened, "result").references).toEqual(snapshot.references);
+ });
+
+ it("captures an independent snapshot and preserves legacy images without inventing history", () => {
+ const config = parseProjectConfig(fixture);
+ const snapshot = imageGenerationSnapshot(config, "Exact submitted prompt", "generator");
+ config.imageScene!.nodes[0].description = "Later edit";
+ config.settings.resolution = "1344p";
+ expect(snapshot.scene.nodes[0].description).not.toBe("Later edit");
+ expect(snapshot.resolution).toBe("768p");
+ expect(snapshot.prompt).toBe("Exact submitted prompt");
+ expect(snapshot.scene.outputAssetId).toBeNull();
+ config.assets = [{ id: "legacy", kind: "image", name: "Legacy", relativePath: "media/generated/legacy.jpg", mimeType: "image/jpeg", createdAt: config.createdAt }];
+ const restored = restoreGeneratedImage(config, "legacy");
+ expect(restored.imageScene).toEqual({ ...config.imageScene, outputAssetId: "legacy" });
+ expect(restored.settings).toEqual(config.settings);
+ });
+
+ it("rejects corrupt snapshot trees and missing or duplicate reference definitions", () => {
+ const snapshot = structuredClone(snapshotFixture);
+ snapshot.scene.nodes[1].parentId = "missing";
+ expect(imageGenerationSnapshotSchema.safeParse(snapshot).success).toBe(false);
+ expect(imageGenerationSnapshotSchema.safeParse({ ...snapshotFixture, references: [] }).success).toBe(false);
+ expect(imageGenerationSnapshotSchema.safeParse({ ...snapshotFixture, references: [...snapshotFixture.references, ...snapshotFixture.references] }).success).toBe(false);
+ });
+});
diff --git a/src/lib/imageHistory.ts b/src/lib/imageHistory.ts
new file mode 100644
index 0000000..7a789e1
--- /dev/null
+++ b/src/lib/imageHistory.ts
@@ -0,0 +1,34 @@
+import { createImageScene } from "./imageScene";
+import type { ImageGenerationSnapshot, ProjectConfig } from "./project";
+
+export function imageGenerationSnapshot(config: ProjectConfig, prompt: string, generatorTemplateId: string): ImageGenerationSnapshot {
+ const scene = config.imageScene ?? createImageScene(config.brief.prompt);
+ return structuredClone({
+ scene: { ...scene, outputAssetId: null },
+ resolution: config.settings.resolution,
+ aspectRatio: config.settings.aspectRatio,
+ defaultLook: config.settings.defaultLook ?? null,
+ briefPrompt: config.brief.prompt,
+ prompt,
+ generatorTemplateId,
+ references: scene.referenceIds.map((id) => config.references.find((reference) => reference.id === id)!),
+ });
+}
+
+/** Restore authored inputs without replacing other results or unrelated references. */
+export function restoreGeneratedImage(config: ProjectConfig, id: string): ProjectConfig {
+ const asset = config.assets.find((candidate) => candidate.id === id && candidate.kind === "image");
+ if (!asset) return config;
+ const snapshot = asset.imageGeneration;
+ if (!snapshot) return { ...config, thumbnail: asset.relativePath ?? null,
+ imageScene: { ...(config.imageScene ?? createImageScene(config.brief.prompt)), outputAssetId: id } };
+ const restored = structuredClone(snapshot);
+ const references = new Map(restored.references.map((reference) => [reference.id, reference]));
+ return { ...config, thumbnail: asset.relativePath ?? null,
+ imageScene: { ...restored.scene, outputAssetId: id },
+ settings: { ...config.settings, resolution: restored.resolution, aspectRatio: restored.aspectRatio, defaultLook: restored.defaultLook },
+ brief: { ...config.brief, prompt: restored.briefPrompt, resolution: restored.resolution, aspectRatio: restored.aspectRatio },
+ references: [...config.references.map((reference) => references.get(reference.id) ?? reference),
+ ...restored.references.filter((reference) => !config.references.some((current) => current.id === reference.id))],
+ };
+}
diff --git a/src/lib/project.ts b/src/lib/project.ts
index 945b9f6..33c7b98 100644
--- a/src/lib/project.ts
+++ b/src/lib/project.ts
@@ -138,6 +138,23 @@ export const LEGACY_RESOLUTIONS = ["720p", "1080p", "4k"] as const;
export const resolutionSchema = z.enum([...PROJECT_RESOLUTIONS, ...LEGACY_RESOLUTIONS]);
+export const imageGenerationSnapshotSchema = z.object({
+ scene: imageSceneSchema,
+ resolution: resolutionSchema,
+ aspectRatio: aspectRatioSchema,
+ defaultLook: z.string().regex(SHOT_TAG_ID_PATTERN).nullable(),
+ briefPrompt: z.string(),
+ prompt: z.string(),
+ generatorTemplateId: z.string().min(1),
+ references: z.array(z.lazy(() => projectReferenceSchema)).max(100),
+}).superRefine((snapshot, context) => {
+ const ids = new Set(snapshot.references.map((reference) => reference.id));
+ if (ids.size !== snapshot.references.length || snapshot.scene.referenceIds.some((id) => !ids.has(id))) {
+ context.addIssue({ code: z.ZodIssueCode.custom, message: "Image generation references must have unique IDs and include every selected reference." });
+ }
+});
+export type ImageGenerationSnapshot = z.infer<typeof imageGenerationSnapshotSchema>;
+
export const projectAssetSchema = z.object({
id: idSchema,
kind: z.enum(["video", "audio", "image", "caption", "generated"]),
@@ -161,9 +178,13 @@ export const projectAssetSchema = z.object({
height: z.number().int().positive().nullish(),
/** Whether the container has an audio stream. */
hasAudio: z.boolean().nullish(),
+ imageGeneration: imageGenerationSnapshotSchema.nullish(),
createdAt: isoDateSchema,
}).superRefine((asset, context) => {
checkOneLocation(asset, context, `Asset '${asset.id}'`);
+ if (asset.imageGeneration && asset.kind !== "image") {
+ context.addIssue({ code: z.ZodIssueCode.custom, path: ["imageGeneration"], message: "Only image assets can store image generation history." });
+ }
/* A scene may be arranged on the timeline before it has been rendered. Its
* generated asset is the stable thing the clip points at while the file is
* still absent; WorkQueue fills the path in when rendering ends. */
diff --git a/src/lib/workQueue.test.ts b/src/lib/workQueue.test.ts
index c7b4a2c..60ab775 100644
--- a/src/lib/workQueue.test.ts
+++ b/src/lib/workQueue.test.ts
@@ -107,12 +107,16 @@ describe("image generation work", () => {
expect(saved.imageScene?.background).toBe("Edited during generation");
expect(saved.imageScene?.outputAssetId).toBe(request.jobId);
expect(saved.assets[0]).toMatchObject({ kind: "image", mimeType: "image/jpeg", relativePath: "media/generated/still.jpg", width: 768, height: 768 });
+ expect(saved.assets[0].imageGeneration).toMatchObject({ resolution: "768p", aspectRatio: "1:1", prompt: request.prompt, generatorTemplateId: template.id });
+ expect(saved.assets[0].imageGeneration!.scene.background).not.toBe("Edited during generation");
+ expect(saved.assets[0].imageGeneration!.scene.outputAssetId).toBeNull();
expect(saved.settings.resolution).toBe("1344p");
expect(saved.generationJobs).toHaveLength(0);
expect(saveGeneratedScene).not.toHaveBeenCalled();
expect(releaseRendered).toHaveBeenCalledWith(request.jobId);
expect(parseProjectConfig(JSON.parse(JSON.stringify(saved))).imageScene).toEqual(saved.imageScene);
expect(parseProjectConfig(JSON.parse(JSON.stringify(saved))).assets[0]).toMatchObject({ width: 768, height: 768 });
+ expect(parseProjectConfig(JSON.parse(JSON.stringify(saved))).assets[0].imageGeneration).toEqual(saved.assets[0].imageGeneration);
queue.enqueueImage(session, template);
await waitFor(() => expect(enqueueSlopfabGeneration).toHaveBeenCalledTimes(2));
const nextRequest = vi.mocked(enqueueSlopfabGeneration).mock.calls[1][0];
diff --git a/src/lib/workQueue.ts b/src/lib/workQueue.ts
index 7acd1e6..e588f52 100644
--- a/src/lib/workQueue.ts
+++ b/src/lib/workQueue.ts
@@ -2,6 +2,8 @@ import { listen } from "@tauri-apps/api/event";
import { invoke } from "@tauri-apps/api/core";
import { createImageScene, imageScenePrompt } from "./imageScene";
import { compileImagePrompt } from "./imagePrompt";
+import { imageGenerationSnapshot } from "./imageHistory";
+import type { ImageGenerationSnapshot } from "./project";
import { outputDimensions } from "./export";
import { projectItemPath, referenceImages, referenceRefmodInputs } from "./project";
import { engineProviderSetting, type GeneratorTemplate } from "./settings";
@@ -39,6 +41,7 @@ export interface WorkItem {
}
interface PendingWork {
image?: boolean;
+ imageGeneration?: ImageGenerationSnapshot;
id: string;
session: ProjectSession;
sceneId: string;
@@ -215,7 +218,7 @@ export class WorkQueue {
referencePaths: references.flatMap((reference) => referenceImages(reference).map((image) => projectItemPath(session.record.folderPath, image)!)),
refmods: referenceRefmodInputs(session.record.folderPath, references),
};
- this.work.set(id, { id, image: true, session, sceneId: scene.nodes.find((node) => node.kind === "root")!.id, config, snapshot: JSON.stringify(scene), request, submitted: false, cancelled: false, done, finish });
+ this.work.set(id, { id, image: true, imageGeneration: imageGenerationSnapshot(config, prompt, template.id), session, sceneId: scene.nodes.find((node) => node.kind === "root")!.id, config, snapshot: JSON.stringify(scene), request, submitted: false, cancelled: false, done, finish });
this.items = [...this.items, { id, kind: "image", projectKey, folderPath: session.record.folderPath, projectName: config.name, sceneId: scene.nodes.find((node) => node.kind === "root")!.id,
title: "Image · " + config.name, submittedAt: new Date().toISOString(), status: "queued", progress: 0, detail: "Waiting to generate image", error: null, completionAt: null, cancelling: false, needsSave: false,
settings: { frames: 1, steps: request.steps, seed: request.seed, canvasWidth: width, canvasHeight: height } }];
@@ -398,7 +401,7 @@ export class WorkQueue {
const saved = await invoke<{ relativePath: string; width: number; height: number }>("save_generated_image", { folderPath: work.session.record.folderPath, jobId: work.id });
work.session.update((current) => ({ ...current, thumbnail: saved.relativePath,
imageScene: { ...(current.imageScene ?? createImageScene()), outputAssetId: work.id },
- assets: [...current.assets, { id: work.id, kind: "image", name: `Image ${current.assets.filter((asset) => asset.kind === "image").length + 1}`, ...saved, mimeType: "image/jpeg", createdAt: new Date().toISOString() }],
+ assets: [...current.assets, { id: work.id, kind: "image", name: `Image ${current.assets.filter((asset) => asset.kind === "image").length + 1}`, ...saved, imageGeneration: work.imageGeneration, mimeType: "image/jpeg", createdAt: new Date().toISOString() }],
}));
try { await work.session.save(); this.patch(work.id, { status: "completed", progress: 1, detail: "Image saved" }); }
catch (reason) { this.patch(work.id, { status: "failed", progress: 1, needsSave: true, detail: "Image created; project save failed", error: describeDiagnosticError(reason) }); }