@gentbajko/slopify 3.15.0 → 3.16.0

package/dist/edge/http/storage.js

@@ -6,7 +6,7 @@ import { BackupBusyError, planBackup, streamBackup, } from "../../slices/storage
 import { BackupImportRefused, importBackup } from "../../slices/storage/backup-import.js";
 import { importPortable, portableMaxArchiveBytes, storageUsage, } from "../../slices/storage/portable.js";
 import { reconcileStorage } from "../../slices/storage/reconcile.js";
-import { keepOutputsOnly, projectStorage } from "../../slices/storage/trim.js";
+import { cleanUpAll, deleteAllOldVersions, deleteOldVersions, keepOutputsOnly, projectStorage, } from "../../slices/storage/trim.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const idParam = z.object({
     id: z
@@ -57,6 +57,31 @@ export function storageRoutes(deps) {
                 detail: "Only a finished project can drop its working files, and this one is running, waiting or has unfinished steps. Let it finish (or cancel it on its project page), then drop the working files again from the project page or Settings → Storage.",
             });
     })
+        // Delete old versions: one project's History files (`slices/storage/trim.ts`).
+        .post("/projects/:id/old-versions/delete", zValidator("param", idParam, onInvalid), (c) => {
+        const result = deleteOldVersions({ db: deps.db, paths: deps.paths, hasInflight: deps.runner.hasInflight }, c.req.valid("param").id);
+        if (result.ok)
+            return c.json(result);
+        return result.reason === "no-project"
+            ? problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This project no longer exists. Reload Settings → Backup & storage to see the current list.",
+            })
+            : problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "This project is running or has steps waiting to run, and its files stay where they are until then. Let it finish, or cancel its run on its project page, then press Delete old versions again.",
+            });
+    })
+        // Every project's old versions; ones that are running are left for later.
+        .post("/old-versions/delete", (c) => c.json(deleteAllOldVersions({
+        db: deps.db,
+        paths: deps.paths,
+        hasInflight: deps.runner.hasInflight,
+    })))
+        // Clean up: old versions everywhere and working files of every finished project.
+        .post("/cleanup", (c) => c.json(cleanUpAll({ db: deps.db, paths: deps.paths, hasInflight: deps.runner.hasInflight })))
         // What Export everything would write, asked before the download starts: a download
         // link cannot show a refusal, the browser would save it as the file.
         .get("/export/summary", (c) => {

package/dist/patch-notes/3.16.0.md

@@ -0,0 +1,10 @@
+# Slopify 3.16.0
+
+Released 9 October 2026.
+
+- **Free space from inside Slopify.** Settings → Backup & storage → Disk space now shows each project's old versions (its History folder) next to its outputs and working files, and offers:
+  - **Delete old versions** on each project, and on a finished project's page under Free space: removes earlier renders and narration, and keeps the current version.
+  - **Delete all old versions**, for every project at once.
+  - **Clean up everything**: old versions for every project, and the working files of every finished one (Keep outputs only). Projects that are running or not finished keep everything.
+
+  Each asks first and says how much it frees. Your uploads and anything you put in History yourself are never removed. Going back to an old version, or changing a project later, makes those files again.

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "3.16.0",
+    "title": "Slopify 3.16.0",
+    "version": "3.16.0",
+    "date": "2026-10-09"
+  },
   {
     "id": "3.15.0",
     "title": "Slopify 3.15.0",

package/dist/slices/storage/trim.js

@@ -1,7 +1,8 @@
-import { existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { existsSync, readdirSync, rmdirSync, statSync, unlinkSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 import { derive } from "../../kernel/runner/graph.js";
-import { projectExists, projectPaused, stagesOf } from "../admission/repo.js";
+import { liveProject, projectExists, projectPaused, stagesOf } from "../admission/repo.js";
+import { projectSettled } from "./arrange.js";
 import { backupsFolderName, outputPath, projectDir } from "./layout.js";
 import { pieceFile } from "./reconcile.js";
 // Keep outputs only: a finished project drops the working files it was made from (images,
@@ -37,7 +38,14 @@ export function projectStorage(deps, projectId) {
     let workingBytes = 0;
     let removableFiles = 0;
     let removableBytes = 0;
+    const history = historyPaths(deps, projectId);
+    let historyFiles = 0;
+    let historyBytes = 0;
     for (const [path, bytes] of files) {
+        if (history.has(path)) {
+            historyFiles += 1;
+            historyBytes += bytes;
+        }
         if (outputs.has(path))
             outputsBytes += bytes;
         else
@@ -52,9 +60,110 @@ export function projectStorage(deps, projectId) {
         workingBytes,
         removableFiles,
         removableBytes,
+        historyFiles,
+        historyBytes,
         finished: finished(deps, projectId),
     };
 }
+// Delete old versions: the files of older versions that arranging moved to History/, by their
+// stored paths. Never a file the user supplied, nor one they put in History themselves. Going
+// back to such a version makes its files again.
+function historyPaths(deps, projectId) {
+    const supplied = suppliedPaths(deps.db, projectId);
+    const out = new Set();
+    for (const [path, place] of placedFiles(deps.paths, projectId))
+        if (place.startsWith("History/") && !supplied.has(path))
+            out.add(path);
+    return out;
+}
+function placedFiles(paths, projectId) {
+    const places = paths.places;
+    return places !== undefined && "placesOf" in places
+        ? places.placesOf(projectId)
+        : new Map();
+}
+export function deleteOldVersions(deps, projectId) {
+    if (!projectExists(deps.db, projectId))
+        return { ok: false, reason: "no-project" };
+    if (deps.hasInflight?.(projectId) === true || !projectSettled(deps.db, projectId))
+        return { ok: false, reason: "busy" };
+    const files = filesOf(deps.paths, projectId);
+    let count = 0;
+    let bytesFreed = 0;
+    for (const path of historyPaths(deps, projectId)) {
+        const bytes = files.get(path);
+        if (bytes === undefined)
+            continue;
+        unlinkSync(outputPath(deps.paths, projectId, path));
+        count += 1;
+        bytesFreed += bytes;
+    }
+    removeEmptyUnder(join(projectDir(deps.paths, projectId), "History"));
+    return { ok: true, files: count, bytesFreed };
+}
+// Every project's old versions, skipping any that runs or waits to run.
+export function deleteAllOldVersions(deps) {
+    const busyIds = [];
+    let projects = 0;
+    let files = 0;
+    let bytesFreed = 0;
+    let busy = 0;
+    for (const row of deps.db.prepare(`SELECT id FROM projects WHERE ${liveProject()}`).all()) {
+        const id = String(row.id);
+        if (placedFiles(deps.paths, id).size === 0)
+            continue;
+        const result = deleteOldVersions(deps, id);
+        if (!result.ok) {
+            if (result.reason === "busy") {
+                busy += 1;
+                busyIds.push(id);
+            }
+            continue;
+        }
+        if (result.files > 0)
+            projects += 1;
+        files += result.files;
+        bytesFreed += result.bytesFreed;
+    }
+    return { projects, files, bytesFreed, busy, busyIds };
+}
+// Clean up: every project's old versions, and the working files of every finished one (Keep
+// outputs only). What runs or waits to run is left as it is.
+export function cleanUpAll(deps) {
+    const old = deleteAllOldVersions(deps);
+    let files = old.files;
+    let bytesFreed = old.bytesFreed;
+    let skipped = old.busy;
+    for (const row of deps.db.prepare(`SELECT id FROM projects WHERE ${liveProject()}`).all()) {
+        const id = String(row.id);
+        const result = keepOutputsOnly(deps, id);
+        if (result.ok) {
+            files += result.files;
+            bytesFreed += result.bytesFreed;
+        }
+        else if (result.reason === "not-finished" && !old.busyIds.includes(id))
+            skipped += 1;
+    }
+    return { files, bytesFreed, skipped };
+}
+// The folders under `root` left empty, deepest first, and `root` itself if it is empty then.
+function removeEmptyUnder(root) {
+    if (!existsSync(root))
+        return;
+    const walk = (dir) => {
+        let empty = true;
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (entry.isDirectory() && walk(join(dir, entry.name))) {
+                rmdirSync(join(dir, entry.name));
+                continue;
+            }
+            empty = false;
+        }
+        return empty;
+    };
+    if (walk(root))
+        rmdirSync(root);
+}
 export function keepOutputsOnly(deps, projectId) {
     if (!projectExists(deps.db, projectId))
         return { ok: false, reason: "no-project" };
@@ -114,7 +223,11 @@ function outputPaths(db, projectId) {
 // The outputs, and every file the user supplied: an asset any saved revision or the project's
 // settings name, or a legacy output row that came from an upload.
 function keptPaths(db, projectId) {
-    const kept = new Set(outputPaths(db, projectId));
+    return new Set([...outputPaths(db, projectId), ...suppliedPaths(db, projectId)]);
+}
+// The files the user supplied: nothing could make them again, so nothing removes them.
+function suppliedPaths(db, projectId) {
+    const kept = new Set();
     for (const path of pathsOf(db
         .prepare(`SELECT a.path FROM project_assets a WHERE a.project_id=? AND (
            EXISTS(SELECT 1 FROM project_revisions r WHERE r.project_id=a.project_id

package/dist/tutorials/Where-Your-Files-Live.md

@@ -142,6 +142,16 @@ If you change that project later (edit an image, a caption style or the narratio
 
 A finished project's own page offers the same in its right rail: **Free space** with **Free 1.2 GB: keep the outputs, drop the working files** (see [Project Page](Project-Page#free-space)).
 
+### Delete old versions and Clean up everything
+
+**Delete old versions** removes a project's `History/` folder: the files of earlier versions, such as a previous render or the narration before a voice change. The current version in `Upload/` and `Working/`, your uploads and anything you put in History yourself stay. Going back to one of those versions makes its files again, which takes time and provider credits.
+
+- **One project:** the **Delete old versions** button on its row in **Disk space**, or under **Free space** on its project page. It says how much it frees.
+- **Every project:** **Delete all old versions** above the **Disk space** list.
+- **Clean up everything** does Delete old versions for every project and **Keep outputs only** for every finished one. Projects that are running or not finished keep everything.
+
+Each asks first. Deleting the files in your file manager works the same way.
+
 ### Clear leftover files
 
 **Clear leftover files** deletes files in the projects folder that no project records any more (never anything in a project's `Upload/`, `Working/` or `History/`, and never a folder Slopify did not make), and uploaded files that no draft, template or project uses. Your projects, outputs and library are never touched. Slopify also does this each time it starts; use it after a crash or to free space now.