@gentbajko/slopify 2.3.1 → 2.4.0

package/dist/adapter-registry.js

@@ -66,7 +66,7 @@ export function buildRegistry(deps) {
     // Replicate also takes the clock: `Prefer: wait` gives up after 60 s and the prediction has
     // to be polled, and the wait is spent on the app's clock so a test never sits through one.
     const images = new Map([
-        ["fal", falImage({ fetch: deps.fetch, key: keyOf("fal") })],
+        ["fal", falImage({ fetch: deps.fetch, key: keyOf("fal"), clock: deps.clock })],
         [
             "replicate",
             replicateImage({ fetch: deps.fetch, key: keyOf("replicate"), clock: deps.clock }),

package/dist/adapters/image/fal.js

@@ -1,13 +1,14 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { httpFailure, missingKey, noImage, unreadable } from "../explain.js";
+import { httpFailure, internalError, missingKey, noImage, providerSaid, unreadable, } from "../explain.js";
 import { retryAfter } from "../retry-after.js";
 import { downloadImage } from "./bytes.js";
+import { dataUri, downloadVideo } from "./video.js";
 // The HTTP gateway adapter for fal.ai: `fetch` and the downloader beside this file, no SDK.
-// `@fal-ai/client` would buy queue polling this endpoint does not need, so the platform's
-// own `fetch` covers the whole call. The synchronous host runs the model on the open
-// connection, which is what the wrapper's 300 s measures.
+// `@fal-ai/client` would buy queue polling, which only the video clips need and which is three
+// plain requests, so the platform's own `fetch` covers every call. Images use the synchronous
+// host, which runs the model on the open connection the wrapper's 300 s measures.
 export const falBase = "https://fal.run";
 // fal has no endpoint listing only its text-to-image models, so the list is this adapter's own
 // data and adding one is a line here plus its aspect shape below.
@@ -48,6 +49,26 @@ function aspectOf(model, aspect) {
     const shape = field ?? "image_size";
     return { [shape]: sizes[shape][aspect] };
 }
+// Image-to-video runs on fal's queue, not the synchronous host: a clip takes one to five
+// minutes, and fal documents the queue as the way to call anything that slow. A request is
+// submitted, its status polled until it completes, and its answer fetched from the links the
+// submission gave.
+export const falQueueBase = "https://queue.fal.run";
+export const falPollMs = 5000;
+// The image-to-video models this adapter knows the inputs of. Each takes `prompt`,
+// `image_url` and a `duration` string; the rest is per model. A model not listed gets only
+// those three.
+const videoInputs = {
+    "fal-ai/kling-video/v2.5-turbo/pro/image-to-video": () => ({}),
+    "fal-ai/wan-25-preview/image-to-video": () => ({ resolution: "720p" }),
+    "fal-ai/bytedance/seedance/v1/pro/fast/image-to-video": (aspect) => ({
+        resolution: "720p",
+        aspect_ratio: aspect,
+    }),
+};
+const queued = z.object({ status_url: z.string(), response_url: z.string() });
+const queueStatus = z.object({ status: z.string(), error: z.string().nullish() });
+const video = z.object({ video: z.object({ url: z.string() }) });
 // A wire payload is narrowed, never cast: everything unlisted is dropped at the seam.
 const generated = z.object({
     images: z.array(z.object({ url: z.string() })),
@@ -99,8 +120,58 @@ export function falImage(deps) {
                 signal: req.signal,
             });
         },
+        animate: async (req) => {
+            const clock = deps.clock;
+            if (clock === undefined)
+                throw providerError({ kind: "other", message: internalError("fal.ai has no clock") });
+            const headers = { Authorization: `Key ${keyOf(deps)}`, "Content-Type": "application/json" };
+            const submitted = await deps.fetch(`${falQueueBase}/${req.model}`, {
+                method: "POST",
+                signal: req.signal,
+                headers,
+                body: JSON.stringify({
+                    prompt: req.prompt,
+                    image_url: dataUri(req.image),
+                    duration: String(Math.round(req.seconds)),
+                    ...(Object.hasOwn(videoInputs, req.model) ? videoInputs[req.model]?.(req.aspect) : {}),
+                }),
+            });
+            if (!submitted.ok)
+                throw await failure(submitted, "video clip request");
+            const links = read(queued, await submitted.text());
+            for (;;) {
+                const status = await deps.fetch(links.status_url, { signal: req.signal, headers });
+                if (!status.ok)
+                    throw await failure(status, "video clip request");
+                const current = read(queueStatus, await status.text());
+                if (current.error)
+                    throw providerError({
+                        kind: "other",
+                        message: providerSaid("fal.ai", "could not make the video clip", redact(current.error), "Use Retry stage; if it keeps happening, choose another image-to-video model under Animate images in Edit project → Inputs → Look."),
+                    });
+                if (current.status === "COMPLETED")
+                    break;
+                await clock.sleep(falPollMs, req.signal);
+            }
+            const answer = await deps.fetch(links.response_url, { signal: req.signal, headers });
+            if (!answer.ok)
+                throw await failure(answer, "video clip request");
+            const made = read(video, await answer.text());
+            return await downloadVideo({
+                fetch: deps.fetch,
+                provider: "fal.ai",
+                url: made.video.url,
+                signal: req.signal,
+            });
+        },
     };
 }
+function read(schema, text) {
+    const parsed = schema.safeParse(safeJson(text));
+    if (!parsed.success)
+        throw providerError({ kind: "other", message: unreadable("fal.ai") });
+    return parsed.data;
+}
 function keyOf(deps) {
     // `missing_key`, not `auth`, because that rule makes it terminal.
     const key = deps.key();
@@ -134,7 +205,7 @@ function kindOf(status) {
     // has to reach the port's error contract first, which is not this adapter's to widen.
     return "other";
 }
-async function failure(response) {
+async function failure(response, subject = "image request") {
     const text = await response.text().catch(() => "");
     // The provider's own words, through the redactor - an error body may quote the key back.
     const message = redact(detailOf(text) || response.statusText);
@@ -145,7 +216,7 @@ async function failure(response) {
             provider: "fal.ai",
             status: response.status,
             detail: message,
-            subject: "image request",
+            subject,
         }),
         ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
     });

package/dist/adapters/image/replicate.js

@@ -4,6 +4,7 @@ import { providerError } from "../../kernel/ports/model.js";
 import { httpFailure, missingKey, noImage, providerSaid, refusedImage, unreadable, } from "../explain.js";
 import { retryAfter } from "../retry-after.js";
 import { downloadImage } from "./bytes.js";
+import { dataUri, downloadVideo } from "./video.js";
 // The HTTP gateway adapter for Replicate: `fetch`, the injected clock and the downloader
 // beside this file, no SDK. The `replicate` package wraps exactly the two requests below, so
 // the platform's own `fetch` covers it.
@@ -71,8 +72,46 @@ export function replicateImage(deps) {
                 signal: req.signal,
             });
         },
+        // The same prediction, polled the same way; a clip outlives `Prefer: wait` every time, so
+        // it is not asked for.
+        animate: async (req) => {
+            const response = await deps.fetch(`${replicateBase}/models/${req.model}/predictions`, {
+                method: "POST",
+                signal: req.signal,
+                headers: { ...auth(deps), "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    input: {
+                        prompt: req.prompt,
+                        [Object.hasOwn(videoImageField, req.model)
+                            ? (videoImageField[req.model] ?? "image")
+                            : "image"]: dataUri(req.image),
+                        duration: Math.round(req.seconds),
+                        ...(Object.hasOwn(videoResolution, req.model) ? { resolution: "720p" } : {}),
+                    },
+                }),
+            });
+            if (!response.ok)
+                throw await failure(response, "video clip request");
+            const url = await settle(deps, parse(await response.text()), req.signal);
+            return await downloadVideo({
+                fetch: deps.fetch,
+                provider: "Replicate",
+                url,
+                signal: req.signal,
+            });
+        },
     };
 }
+// Replicate's image-to-video models name the still differently: Kling calls it
+// `start_image`, the others `image`. Wan and Seedance default to larger frames than the
+// render needs, so they are asked for 720p, which is what the catalogue prices.
+const videoImageField = {
+    "kwaivgi/kling-v2.5-turbo-pro": "start_image",
+};
+const videoResolution = {
+    "wan-video/wan-2.5-i2v": true,
+    "bytedance/seedance-1-pro-fast": true,
+};
 // `Prefer: wait` answers `starting` when the model outlived its 60 s; Replicate's guidance
 // is to poll `urls.get` until the prediction settles.
 async function settle(deps, first, signal) {
@@ -144,7 +183,7 @@ function kindOf(status) {
     // error contract first, which is not this adapter's to widen.
     return "other";
 }
-async function failure(response) {
+async function failure(response, subject = "image request") {
     const text = await response.text().catch(() => "");
     const parsed = errorBody.safeParse(safeJson(text));
     // The provider's own words, through the redactor - an error body may quote the key back.
@@ -157,7 +196,7 @@ async function failure(response) {
             provider: "Replicate",
             status: response.status,
             detail: message || response.statusText,
-            subject: "image request",
+            subject,
         }),
         ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
     });

package/dist/adapters/image/video.js

@@ -0,0 +1,28 @@
+import { providerError } from "../../kernel/ports/model.js";
+import { describeBytes } from "./bytes.js";
+// What the two image-to-video adapters share: the still goes up inline as a data URI (the
+// render sends a small JPEG, `slices/rebuild/runtime-animate.ts`), and the clip comes back
+// as a link that is downloaded inside the attempt, like an image.
+export function dataUri(image) {
+    return `data:${image.mime};base64,${Buffer.from(image.bytes).toString("base64")}`;
+}
+// An MP4 (or MOV) names its box type at byte 4.
+export function sniffVideo(bytes) {
+    return bytes.length > 12 && Buffer.from(bytes.slice(4, 8)).toString("latin1") === "ftyp";
+}
+export async function downloadVideo(download) {
+    const response = await download.fetch(download.url, { signal: download.signal });
+    if (!response.ok)
+        // The link is not quoted back: a delivery link carries its own signature.
+        throw providerError({
+            kind: "other",
+            message: `${download.provider} made the video clip, but Slopify could not download it (error ${String(response.status)}). Check your internet connection, then use Retry stage.`,
+        });
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (!sniffVideo(bytes))
+        throw providerError({
+            kind: "other",
+            message: `${download.provider} sent back something that is not an MP4 video clip (${describeBytes(bytes)}). Use Retry stage; if it keeps happening, choose another image-to-video model under Animate images in Edit project → Inputs → Look.`,
+        });
+    return { bytes, mime: "video/mp4" };
+}

package/dist/assets/fonts/SOURCE.txt

@@ -2,6 +2,12 @@ Barlow-Regular.ttf
 Source: https://raw.githubusercontent.com/google/fonts/6cdf01867df0813c2390f90dff7dc66c87f14cf7/ofl/barlow/Barlow-Regular.ttf
 SHA-256: 95aa02c7c43096e0dd44d787ba6216864a67157e402adab59b35572e0c1577ea
 
+Barlow-Bold.ttf
+Source: https://raw.githubusercontent.com/google/fonts/6cdf01867df0813c2390f90dff7dc66c87f14cf7/ofl/barlow/Barlow-Bold.ttf
+SHA-256: 84e6a4d61e7c3e21f3c50ea6a4f7e5303a3467864c038be6ea3759bab8d547f9
+Git blob: 2f20cbe667ca5cd871410dc50dc4b1a30c1d6267 (matches the google/fonts tree at that commit)
+Licence: SIL Open Font License 1.1, OFL.txt below (the same licence and authors as Barlow-Regular)
+
 OFL.txt
 Source: https://raw.githubusercontent.com/google/fonts/6cdf01867df0813c2390f90dff7dc66c87f14cf7/ofl/barlow/OFL.txt
 SHA-256: 186d750eb496a4c17a76385f82be6aea2ac1cf2de074a811d63786cf374ea73f

package/dist/assets/models.yaml

@@ -2,7 +2,7 @@
 # A private copy in the Slopify data directory reloads automatically.
 # Omitted pricing means unknown, never free. Provider concurrency is capped at five.
 schemaVersion: 1
-updatedAt: 2026-09-24
+updatedAt: 2026-09-26
 providers:
   openrouter:
     maxConcurrent: 3
@@ -237,6 +237,87 @@ image:
     pricing:
       note: Price depends on your account or generated output; estimate unavailable.
     image: *a4
+  # Image-to-video models, marked by the `video` keyword: Animate images turns a still into a
+  # 5-second clip with one of these. perImage is the price of one 5-second clip.
+  - provider: fal
+    id: fal-ai/kling-video/v2.5-turbo/pro/image-to-video
+    name: Kling 2.5 Turbo Pro (image to video)
+    source: https://fal.ai/models/fal-ai/kling-video/v2.5-turbo/pro/image-to-video
+    keywords:
+      - video
+    pricing:
+      perImage: 0.35
+      note: Public fal.ai rate verified 2026-09-26, one 5-second clip.
+    image:
+      aspectRatios:
+        - 16:9
+        - 9:16
+  - provider: fal
+    id: fal-ai/wan-25-preview/image-to-video
+    name: Wan 2.5 (image to video, 720p)
+    source: https://fal.ai/models/fal-ai/wan-25-preview/image-to-video
+    keywords:
+      - video
+    pricing:
+      perImage: 0.5
+      note: Public fal.ai rate verified 2026-09-26, $0.10 a second at 720p, one 5-second clip.
+    image:
+      aspectRatios:
+        - 16:9
+        - 9:16
+  - provider: fal
+    id: fal-ai/bytedance/seedance/v1/pro/fast/image-to-video
+    name: Seedance 1.0 Pro Fast (image to video, 720p)
+    source: https://fal.ai/models/fal-ai/bytedance/seedance/v1/pro/fast/image-to-video
+    keywords:
+      - video
+    pricing:
+      perImage: 0.12
+      note: fal.ai bills by video tokens; about $0.12 for a 5-second 720p clip (verified
+        2026-09-26), more for larger frames.
+    image:
+      aspectRatios:
+        - 16:9
+        - 9:16
+  - provider: replicate
+    id: kwaivgi/kling-v2.5-turbo-pro
+    name: Kling 2.5 Turbo Pro (image to video)
+    source: https://replicate.com/kwaivgi/kling-v2.5-turbo-pro
+    keywords:
+      - video
+    pricing:
+      perImage: 0.35
+      note: Public Replicate rate verified 2026-09-26, $0.07 a second, one 5-second clip.
+    image:
+      aspectRatios:
+        - 16:9
+        - 9:16
+  - provider: replicate
+    id: wan-video/wan-2.5-i2v
+    name: Wan 2.5 (image to video, 720p)
+    source: https://replicate.com/wan-video/wan-2.5-i2v
+    keywords:
+      - video
+    pricing:
+      perImage: 0.5
+      note: Public Replicate rate verified 2026-09-26, $0.10 a second at 720p, one 5-second clip.
+    image:
+      aspectRatios:
+        - 16:9
+        - 9:16
+  - provider: replicate
+    id: bytedance/seedance-1-pro-fast
+    name: Seedance 1 Pro Fast (image to video, 720p)
+    source: https://replicate.com/bytedance/seedance-1-pro-fast
+    keywords:
+      - video
+    pricing:
+      perImage: 0.125
+      note: Public Replicate rate verified 2026-09-26, $0.025 a second at 720p, one 5-second clip.
+    image:
+      aspectRatios:
+        - 16:9
+        - 9:16
 tts:
   - provider: elevenlabs
     id: eleven_v3

package/dist/catalog/schema.js

@@ -89,3 +89,13 @@ export const catalogueSchema = z
                 });
         }
 });
+// Image-to-video models live in the image list, under the image providers that run them,
+// marked by the `video` keyword; their perImage is the price of one clip. A catalogue that
+// older Slopify versions read keeps its shape, and the image pickers leave these out.
+export function isVideoModel(model) {
+    return model.keywords.includes("video");
+}
+// The image-to-video models a provider offers, as Animate images lists them.
+export function videoModelsOf(catalogue, provider) {
+    return catalogue.image.filter((m) => m.provider === provider && m.enabled && !m.deprecated && isVideoModel(m));
+}

package/dist/catalog/store.js

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSyn
 import { join } from "node:path";
 import { parse } from "yaml";
 import { isLocalCliProvider } from "../slices/settings/model.js";
-import { catalogueSchema } from "./schema.js";
+import { catalogueSchema, isVideoModel } from "./schema.js";
 export const catalogueSource = "https://raw.githubusercontent.com/GentBajko/slopify/main/packages/app/src/assets/models.yaml";
 export function parseCatalogue(text) {
     if (Buffer.byteLength(text) > 1024 * 1024)
@@ -86,7 +86,7 @@ export function createCatalogueStore(deps) {
     }
     return {
         read,
-        models: (provider, family) => read()[family].filter((m) => m.provider === provider && m.enabled && !m.deprecated),
+        models: (provider, family) => read()[family].filter((m) => m.provider === provider && m.enabled && !m.deprecated && !isVideoModel(m)),
         status: () => ({ updatedAt: read().updatedAt, path, warning, source: catalogueSource }),
         refresh: () => {
             refreshing ??= refresh().finally(() => {

package/dist/catalog/validate.js

@@ -1,5 +1,7 @@
-import { usesNarrationPreparation, usesYoutubeDescription, } from "../slices/admission/rules.js";
+import { usesNarrationPreparation, usesShorts, usesYoutubeDescription, } from "../slices/admission/rules.js";
 import { isLocalCliProvider } from "../slices/settings/model.js";
+import { usesAnimation } from "../slices/video/edit-settings.js";
+import { videoModelsOf } from "./schema.js";
 export function modelFields(draft, catalogue) {
     if (!catalogue)
         return [];
@@ -10,7 +12,8 @@ export function modelFields(draft, catalogue) {
         draft.intro?.mode === "llm" ||
         draft.outro?.mode === "llm" ||
         usesNarrationPreparation(draft) ||
-        usesYoutubeDescription(draft);
+        usesYoutubeDescription(draft) ||
+        usesShorts(draft);
     const checks = [
         { field: "llm", family: "llm", choice: draft.llm, needed: needLlm },
         {
@@ -24,7 +27,8 @@ export function modelFields(draft, catalogue) {
             family: "image",
             choice: draft.images,
             needed: draft.sources.images === "generate" ||
-                ["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail),
+                ["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail) ||
+                usesShorts(draft),
         },
     ];
     for (const { field, family, choice, needed } of checks) {
@@ -46,11 +50,35 @@ export function modelFields(draft, catalogue) {
                 field,
                 message: "This model cannot search the web for research. Choose another model or turn Research off.",
             });
-        else if ("image" in model && !model.image.aspectRatios.includes(draft.format))
+        else if ("image" in model &&
+            (draft.sources.images === "generate" ||
+                ["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail)) &&
+            !model.image.aspectRatios.includes(draft.format))
             fields.push({
                 field,
                 message: "This image model cannot make images in this video's shape. Choose another model.",
             });
+        // The shorts are always vertical, whatever shape the video is.
+        else if ("image" in model && usesShorts(draft) && !model.image.aspectRatios.includes("9:16"))
+            fields.push({
+                field,
+                message: "This image model cannot make the vertical (9:16) images Shorts need. Choose another image model, or turn Shorts off.",
+            });
+    }
+    // Animate images runs on the image provider's image-to-video models.
+    if (usesAnimation(draft) && draft.images !== undefined) {
+        const model = draft.videoEdit?.animateModel ?? "";
+        const offered = videoModelsOf(catalogue.read(), draft.images.provider);
+        if (offered.length === 0)
+            fields.push({
+                field: "videoEdit.animateModel",
+                message: "This image provider can't animate images. Choose fal.ai or Replicate as the image provider (on Play's Images rail, or in Edit project → Providers), or turn Animate images off.",
+            });
+        else if (model.trim() !== "" && !offered.some((one) => one.id === model))
+            fields.push({
+                field: "videoEdit.animateModel",
+                message: "This image-to-video model is no longer in Slopify's model list. Choose another under Animate images.",
+            });
     }
     return fields;
 }

package/dist/edge/docker-launch.js

@@ -62,6 +62,10 @@ async function main() {
         console.log(`Project files on this machine: ${result.projects}`);
         if (result.recovery)
             console.log(`Recovery volume retained: ${result.recovery}. Previous containers remain stopped.`);
+        for (const name of result.pruned.removed)
+            console.log(`Removed older recovery volume: ${name}`);
+        for (const problem of result.pruned.problems)
+            console.warn(problem);
     }
     finally {
         process.off("SIGINT", abort);

package/dist/edge/docker-projects/engine.js

@@ -4,6 +4,24 @@ import { setTimeout as delay } from "node:timers/promises";
 import { z } from "zod";
 import { containerSchema, digestSchema, } from "./state.js";
 import { contains } from "./tree.js";
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+// A recovery volume says which update, installation and container made it. Earlier launchers
+// set only the transaction label; `prune.ts` asks those for the update's own record instead.
+export function recoveryLabels(j) {
+    return {
+        "io.slopify.transaction": j.id,
+        "io.slopify.installation": j.installation,
+        "io.slopify.container": j.name,
+    };
+}
+// The id a recovery volume of `volume` carries in its name, or null for any other volume.
+export function recoveryId(volume, name) {
+    const prefix = `${volume}-recovery-`;
+    if (!name.startsWith(prefix))
+        return null;
+    const id = name.slice(prefix.length);
+    return uuid.test(id) ? id : null;
+}
 // Docker's exit code alone says nothing, so its last error line decides the advice: the daemon
 // being stopped and the socket being off-limits are by far the most common first-run failures.
 export function dockerFailure(args, result) {
@@ -294,9 +312,47 @@ export function dockerEngine(runner, signal, env) {
             const all = (await command(["volume", "ls", "--format", "{{.Name}}"])).split(/\s+/);
             if (all.includes(j.backup))
                 throw new Error("Recovery volume already exists; reconcile the journal before retrying.");
-            await command(["volume", "create", "--label", `io.slopify.transaction=${j.id}`, j.backup]);
+            await command([
+                "volume",
+                "create",
+                ...Object.entries(recoveryLabels(j)).flatMap(([key, value]) => [
+                    "--label",
+                    `${key}=${value}`,
+                ]),
+                j.backup,
+            ]);
             return digestSchema.parse(await helper(j.image, [...source(j.volume, null), ...mount("volume", j.backup, "/backup")], "snapshot"));
         },
+        recoveryVolumes: async (volume) => {
+            const names = (await command([
+                "volume",
+                "ls",
+                "--filter",
+                "label=io.slopify.transaction",
+                "--format",
+                "{{.Name}}",
+            ]))
+                .split(/\s+/)
+                .filter((name) => recoveryId(volume, name) !== null);
+            const found = [];
+            for (const name of names) {
+                const labels = z
+                    .record(z.string(), z.string())
+                    .nullable()
+                    .parse(JSON.parse(await command(["volume", "inspect", "--format", "{{json .Labels}}", name])));
+                found.push({
+                    name,
+                    transaction: labels?.["io.slopify.transaction"] ?? null,
+                    installation: labels?.["io.slopify.installation"] ?? null,
+                    container: labels?.["io.slopify.container"] ?? null,
+                });
+            }
+            return found;
+        },
+        // Never forced: Docker refuses a volume a container still mounts, and that refusal stands.
+        removeVolume: async (name) => {
+            await command(["volume", "rm", name]);
+        },
         restore: async (j) => {
             if (!j.backupDigest)
                 throw new Error("No verified private snapshot; automatic restore is unsafe.");

package/dist/edge/docker-projects/install.js

@@ -4,6 +4,7 @@ import { dirname, join } from "node:path";
 import { readVersion } from "../../kernel/version.js";
 import { assertVolumeClaims } from "./claims.js";
 import { readCommittedJournal } from "./committed.js";
+import { pruneRecoveryVolumes } from "./prune.js";
 import { assertSourceIdentity, recoverInstallation } from "./recover.js";
 import { journalSchema, privateDirectory, readState, receiptSchema, selectProjects, writeState, } from "./state.js";
 import { assertIdentity, assertWritableTree, identity, isMissing, privateTree, safePath, syncDirectory, treeDigest, } from "./tree.js";
@@ -91,7 +92,12 @@ export async function installProjects(c, e, recovery) {
         if (!old.running)
             await e.command(["start", old.id]);
         await e.health(old.id, j.token, expectedVersion);
-        return { url: `http://${old.port}`, projects, recovery: j.backup };
+        return {
+            url: `http://${old.port}`,
+            projects,
+            recovery: j.backup,
+            pruned: { removed: [], problems: [] },
+        };
     }
     const id = randomUUID();
     const directory = join(c.directory, id);
@@ -229,7 +235,9 @@ export async function installProjects(c, e, recovery) {
         const ready = await e.inspect(candidate);
         if (!ready?.port)
             throw new Error("Slopify started but Docker did not report which port it is on. Run the same command again to finish.");
-        return { url: `http://${ready.port}`, projects, recovery: j.backup };
+        // Only now, with the new container committed and healthy, are older snapshots redundant.
+        const pruned = await pruneRecoveryVolumes(c, e, j);
+        return { url: `http://${ready.port}`, projects, recovery: j.backup, pruned };
     }
     catch (cause) {
         const current = await readState(receiptPath, receiptSchema, c.uid);

package/dist/edge/docker-projects/prune.js

@@ -0,0 +1,66 @@
+import { join } from "node:path";
+import { recoveryId } from "./engine.js";
+import { journalSchema, readState } from "./state.js";
+// Phases an update's record is left in once it is over, one way or the other. Anything else
+// is an update that never finished, and its volume may be the only copy of the data.
+const settled = new Set(["healthy", "committed", "restored", "rolled-back"]);
+// After an update is committed and healthy, keep only its own recovery volume. An older one is
+// removed only when all of these hold, so a volume some other installation, container or person
+// made is never touched:
+// - its name is exactly `<this data volume>-recovery-<uuid>`, never the data volume itself;
+// - its io.slopify.transaction label is that same uuid (every launcher has set it);
+// - the container label, which this launcher adds, names this container (earlier launchers
+//   set none, and for those the next check decides alone);
+// - the update's own record, <install dir>/<uuid>/journal.json in this container's private
+//   folder, exists and names this container, data volume and Docker, the installation the
+//   volume's label names, and exactly this volume as its backup, and says that update is
+//   over. A first install that was rolled back has an installation id of its own, so the
+//   id is matched against the volume's label rather than the current update's.
+// Docker refuses to remove a volume a container still uses; that refusal is reported, not
+// forced. Nothing here can fail the update, which has already finished.
+export async function pruneRecoveryVolumes(c, e, j) {
+    const removed = [];
+    const problems = [];
+    let volumes;
+    try {
+        volumes = await e.recoveryVolumes(c.volume);
+    }
+    catch (error) {
+        return {
+            removed,
+            problems: [
+                `Couldn't list older recovery volumes to tidy up, so all of them are kept. See them with docker volume ls --filter label=io.slopify.transaction and remove the ones you no longer need with docker volume rm <name>. ${reason(error)}`,
+            ],
+        };
+    }
+    for (const volume of volumes) {
+        const id = recoveryId(c.volume, volume.name);
+        if (id === null || id === j.id || volume.name === j.backup || volume.name === c.volume)
+            continue;
+        if (volume.transaction !== id)
+            continue;
+        if (volume.container !== null && volume.container !== c.name)
+            continue;
+        const record = await readState(join(c.directory, id, "journal.json"), journalSchema, c.uid).catch(() => null);
+        if (record === null ||
+            record.id !== id ||
+            record.name !== c.name ||
+            record.volume !== c.volume ||
+            record.daemon !== j.daemon ||
+            (volume.installation !== null && volume.installation !== record.installation) ||
+            record.backup !== volume.name ||
+            !settled.has(record.phase))
+            continue;
+        try {
+            await e.removeVolume(volume.name);
+            removed.push(volume.name);
+        }
+        catch (error) {
+            problems.push(`Couldn't remove the older recovery volume ${volume.name}, so it is kept. Once nothing uses it, remove it with docker volume rm ${volume.name}. ${reason(error)}`);
+        }
+    }
+    return { removed, problems };
+}
+function reason(error) {
+    return error instanceof Error ? `Why: ${error.message}` : "";
+}

package/dist/edge/http/providers.js

@@ -1,6 +1,7 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { videoModelsOf } from "../../catalog/schema.js";
 import { cliPathMaxLength, saveCliPath } from "../../slices/settings/cli-paths.js";
 import { keyStatus, removeProviderKey, saveProviderKey } from "../../slices/settings/keys.js";
 import { isLocalCliProvider, providerById, providerIds } from "../../slices/settings/model.js";
@@ -56,6 +57,13 @@ export function providerRoutes(deps) {
         .get("/", async (c) => c.json({ providers: await providerStatuses(readiness) }))
         .get("/:id/models", zValidator("param", providerParam, onInvalid), async (c) => {
         const { id } = c.req.valid("param");
+        // Animate images lists the provider's image-to-video models, which only the catalogue
+        // names.
+        if (c.req.query("video") === "1")
+            return c.json({
+                models: deps.catalogue === undefined ? [] : videoModelsOf(deps.catalogue.read(), id),
+                allowsCustom: false,
+            });
         if (deps.catalogue && !isLocalCliProvider(id))
             return c.json({
                 models: deps.catalogue.models(id, providerById(id).family).map((m) => ({