@gentbajko/slopify 3.15.0 → 3.17.0

package/dist/edge/http/projects.js

@@ -15,7 +15,6 @@ import { adoptBaseline } from "../../slices/revisions/adopt.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { limitWaitsByProject, listingWait } from "../../slices/run-cost/panel.js";
 import { outputsOf } from "../../slices/storage/repo.js";
-import { longVideoStats } from "../../slices/studio/stats.js";
 import { trashProject } from "../../slices/trash/service.js";
 import { setAsideProjects, uploadedAndSettled, uploadedProjects, } from "../../slices/uploads/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
@@ -68,7 +67,6 @@ export function projectRoutes(deps) {
         const uploads = uploadedProjects(deps.db);
         const aside = setAsideProjects(deps.db);
         const settled = uploadedAndSettled(deps.db);
-        const numbers = longVideoStats(deps.db);
         const waits = limitWaitsByProject(deps.db);
         const projects = listProjectHeads(deps.db).map((project) => {
             const stages = standings.get(project.id) ?? [];
@@ -80,12 +78,6 @@ export function projectRoutes(deps) {
                 channelId: channels.get(project.id) ?? defaultChannelId,
                 uploadedAt: uploads.get(project.id) ?? null,
                 ...(aside.has(project.id) ? { setAside: true } : {}),
-                ...(numbers.get(project.id)?.views == null
-                    ? {}
-                    : { views: numbers.get(project.id)?.views ?? 0 }),
-                ...(numbers.get(project.id)?.ctr == null
-                    ? {}
-                    : { ctr: numbers.get(project.id)?.ctr ?? 0 }),
                 ...(waiting === undefined ? {} : { limitWaits: waiting.map(listingWait) }),
             };
         });

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/edge/http/studio.js

@@ -3,7 +3,6 @@ import { join } from "node:path";
 import { Readable } from "node:stream";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
-import { bodyLimit } from "hono/body-limit";
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { derive } from "../../kernel/runner/graph.js";
@@ -16,16 +15,13 @@ import { backfillVideos } from "../../slices/studio/backfill.js";
 import { releaseCalendar } from "../../slices/studio/calendar.js";
 import { playlistUses, studioPlaylistMax, studioUploadUrl, } from "../../slices/studio/model.js";
 import { packItem, uploadPack } from "../../slices/studio/pack.js";
-import { channelPerformance } from "../../slices/studio/performance.js";
 import { writeUploadPick } from "../../slices/studio/pick.js";
 import { postingPlanSchema, readPlan, readStoredPlan, weekdayIn, writePlan, } from "../../slices/studio/plan.js";
 import { leadHoursMax, seriesOf } from "../../slices/studio/plan-model.js";
 import { enqueueFill, fillOnly, readFillQueue, removeFill, } from "../../slices/studio/queue.js";
 import { allReleases, freeSlots, planReleases, readLeadHours, releasesOf, setRelease, swapReleases, writeLeadHours, } from "../../slices/studio/releases.js";
-import { parseStudioExport, readReport, saveReport } from "../../slices/studio/report.js";
-import { statsFromReport } from "../../slices/studio/report-stats.js";
-import { autoCommentKey, bearerToken, exportViewProblem, exportViews, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readExportView, readStudioPlaylists, resetStudioPairing, saveExportView, saveProjectPlaylists, saveRealFootage, saveStudioPlaylists, studioPairing, studioPlaylistsMax, studioPlaylistsProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
-import { abResults, abVariantSchema, projectStats, saveAbResult, saveStats, } from "../../slices/studio/stats.js";
+import { autoCommentKey, bearerToken, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readStudioPlaylists, resetStudioPairing, saveProjectPlaylists, saveRealFootage, saveStudioPlaylists, studioPairing, studioPlaylistsMax, studioPlaylistsProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
+import { abResults, abVariantSchema, saveAbResult } from "../../slices/studio/stats.js";
 import { confirmUpload, doneVideos, forgetVideo, projectVideos, recordedVideos, recordVideo, setChecks, setTaskState, videoIdOf, videoIdPattern, videoOf, waitingTasks, } from "../../slices/studio/videos.js";
 import { setAsideProjects, uploadedProjects } from "../../slices/uploads/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
@@ -89,15 +85,11 @@ const taskResultBody = z.object({
     ok: z.boolean(),
     message: z.string().max(2000),
 });
+// An A/B test's result as Studio shows it; older extensions also send numbers, which are ignored.
 const statsBody = z.object({
     projectId: id,
     short: shortField,
     videoId: z.string().regex(videoIdPattern),
-    impressions: z.number().nonnegative().optional(),
-    ctr: z.number().min(0).max(100).optional(),
-    views: z.number().nonnegative().optional(),
-    averageViewSeconds: z.number().nonnegative().optional(),
-    watchHours: z.number().nonnegative().optional(),
     abVariants: z.array(abVariantSchema).max(3).optional(),
 });
 const backfillBody = z.object({
@@ -192,24 +184,6 @@ export function studioRoutes(deps) {
             .filter((one) => one !== "")
             .toSorted(),
     });
-    // A report and, for each of its videos Slopify made, the project and which upload it is.
-    const reportBody = (channelId) => {
-        const report = readReport(deps.db, channelId);
-        const known = new Map(listProjects(deps.db).flatMap((project) => projectVideos(deps.db, project.id).map((video) => [
-            video.videoId,
-            { projectId: project.id, short: video.short, projectTitle: project.title },
-        ])));
-        return {
-            exportView: readExportView(deps.db, channelId),
-            report,
-            projects: report === null
-                ? {}
-                : Object.fromEntries(report.rows.flatMap((row) => {
-                    const found = known.get(row.videoId);
-                    return found === undefined ? [] : [[row.videoId, found]];
-                })),
-        };
-    };
     const slotChoices = (projectId, series) => freeSlots(deps.db, readPlan(deps.db), whoOf(projectId, series), deps.clock.now(), 9);
     // Finished projects not marked uploaded: the popup's list and the calendar's candidates.
     const finishedProjects = () => {
@@ -469,86 +443,8 @@ export function studioRoutes(deps) {
         return c.json({ chosen: { projectId, short: short ?? null }, queue: queueView(queue) });
     })
         // What waits for the extension, oldest first: each new upload dialog takes the first.
-        // Studio's numbers for a project's videos, and every finished A/B test (Library).
-        .get("/stats/:projectId", zValidator("param", projectParam, onInvalid), (c) => c.json({ stats: projectStats(deps.db, c.req.valid("param").projectId) }))
+        // Every finished A/B test (Library).
         .get("/ab-results", (c) => c.json({ results: abResults(deps.db) }))
-        // Channels → YouTube numbers: Studio's Advanced-mode export, imported as the zip Studio
-        // downloads, and which project each of its videos is.
-        .get("/channels/:channelId/report", zValidator("param", z.object({ channelId: id }), onInvalid), (c) => c.json(reportBody(c.req.valid("param").channelId)))
-        .post("/channels/:channelId/report", zValidator("param", z.object({ channelId: id }), onInvalid), bodyLimit({
-        maxSize: 30 * 1024 * 1024,
-        onError: (c) => problem(c, {
-            status: 413,
-            title: titleOf(413),
-            detail: "That file is larger than 30 MB, which a Studio export never is. Export again from Studio's Advanced mode and import the zip it downloads.",
-        }),
-    }), async (c) => {
-        const denied = samePage(c);
-        if (denied !== undefined)
-            return denied;
-        const { channelId } = c.req.valid("param");
-        const parsed = parseStudioExport(new Uint8Array(await c.req.arrayBuffer()), deps.clock.now().toISOString());
-        if (!parsed.ok)
-            return problem(c, { status: 400, title: titleOf(400), detail: parsed.message });
-        saveReport(deps.db, channelId, parsed.report);
-        statsFromReport(deps.db, parsed.report, parsed.report.importedAt);
-        return c.json(reportBody(channelId));
-    })
-        // The Analytics view the extension exports every day for this channel; null forgets it.
-        .put("/channels/:channelId/export-view", zValidator("param", z.object({ channelId: id }), onInvalid), zValidator("json", z.object({ url: z.string().max(4000).nullable() }), onInvalid), (c) => {
-        const denied = samePage(c);
-        if (denied !== undefined)
-            return denied;
-        const { channelId } = c.req.valid("param");
-        const { url } = c.req.valid("json");
-        const wrong = url === null || url.trim() === "" ? undefined : exportViewProblem(url);
-        if (wrong !== undefined)
-            return problem(c, {
-                status: 400,
-                title: titleOf(400),
-                detail: wrong,
-                extensions: { fields: [{ field: "url", message: wrong }] },
-            });
-        saveExportView(deps.db, channelId, url);
-        return c.json(reportBody(channelId));
-    })
-        // The extension: each channel's Analytics view to export.
-        .get("/ext/export-views", (c) => {
-        allowOrigin(c, false);
-        if (!extAllowed(c))
-            return refused(c);
-        return c.json({ views: exportViews(deps.db) });
-    })
-        // The extension exported a channel's view: the zip Studio's Export makes, as Studio sends
-        // it (base64). Saved as an import would be, and each known video's numbers with it.
-        .post("/ext/report", bodyLimit({
-        maxSize: 40 * 1024 * 1024,
-        onError: (c) => problem(c, {
-            status: 413,
-            title: titleOf(413),
-            detail: "Studio's export was larger than Slopify takes (40 MB).",
-        }),
-    }), zValidator("json", z.object({
-        channelId: id,
-        zippedData: z
-            .string()
-            .min(1)
-            .max(40 * 1024 * 1024),
-    }), onInvalid), (c) => {
-        allowOrigin(c, false);
-        if (!extAllowed(c))
-            return refused(c);
-        const { channelId, zippedData } = c.req.valid("json");
-        const now = deps.clock.now().toISOString();
-        const parsed = parseStudioExport(new Uint8Array(Buffer.from(zippedData, "base64url")), now);
-        if (!parsed.ok)
-            return problem(c, { status: 400, title: titleOf(400), detail: parsed.message });
-        saveReport(deps.db, channelId, parsed.report);
-        const videos = statsFromReport(deps.db, parsed.report, now);
-        return c.json({ rows: parsed.report.rows.length, videos });
-    })
-        // Channels → YouTube: the channel's videos on YouTube with Studio's numbers and totals.
-        .get("/channels/:channelId/performance", zValidator("param", z.object({ channelId: id }), onInvalid), (c) => c.json(channelPerformance(deps, c.req.valid("param").channelId)))
         // The YouTube videos a project's uploads became, and their A/B tests.
         .get("/videos/:projectId", zValidator("param", projectParam, onInvalid), (c) => c.json({ videos: projectVideos(deps.db, c.req.valid("param").projectId) }))
         // A video's link pasted in Slopify, for an upload made without the extension; an empty
@@ -797,13 +693,12 @@ export function studioRoutes(deps) {
         setTaskState(deps.db, task, projectId, short ?? null, ok ? "done" : "failed", message);
         return c.json({ ok: true });
     })
-        // Every video on YouTube, for the numbers the extension reads from Studio.
+        // The long videos whose A/B test is running, for the extension to read each result.
         .get("/ext/known-videos", (c) => {
         allowOrigin(c, false);
         if (!extAllowed(c))
             return refused(c);
         return c.json({
-            // The export brings every video's numbers; only an A/B test's result needs a visit.
             videos: doneVideos(deps.db)
                 .filter((video) => video.short === null && video.abState === "started")
                 .map((video) => ({
@@ -864,26 +759,6 @@ export function studioRoutes(deps) {
             return refused(c);
         const body = c.req.valid("json");
         const readAt = deps.clock.now().toISOString();
-        // A visit for the A/B result alone brings no numbers: the export's are kept.
-        const numbers = [
-            body.impressions,
-            body.ctr,
-            body.views,
-            body.averageViewSeconds,
-            body.watchHours,
-        ].some((one) => one !== undefined);
-        if (numbers)
-            saveStats(deps.db, {
-                projectId: body.projectId,
-                short: body.short ?? null,
-                videoId: body.videoId,
-                readAt,
-                impressions: body.impressions ?? null,
-                ctr: body.ctr ?? null,
-                views: body.views ?? null,
-                averageViewSeconds: body.averageViewSeconds ?? null,
-                watchHours: body.watchHours ?? null,
-            });
         if (body.abVariants !== undefined && body.abVariants.length > 1)
             saveAbResult(deps.db, {
                 projectId: body.projectId,

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/3.17.0.md

@@ -0,0 +1,10 @@
+# Slopify 3.17.0
+
+Released 10 October 2026.
+
+- **YouTube numbers are gone.** Studio's export only carried daily figures for the few videos its chart showed, so the numbers were incomplete. The **YouTube numbers** tab in Channels is removed. So are the views and CTR on the Projects list and the numbers line under each video in **On YouTube**. The extension no longer exports the Analytics view every day or visits each video's Analytics, and the popup's **Read Studio now** is gone. **Library → A/B results** stays: once a day the extension still reads a running A/B test's result from the long video's Details page. (Extension 1.4.0.)
+
+## Upgrading from 3.16.0
+
+- **Nothing becomes outdated.**
+- The extension loaded from Slopify's own folder switches to 1.4.0 by itself. The store version updates through the store.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.17.0",
+    "title": "Slopify 3.17.0",
+    "version": "3.17.0",
+    "date": "2026-10-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/slices/studio/settings.js

@@ -242,38 +242,3 @@ export function studioRequestAllowed(db, token, origin) {
         return true;
     return pairing.origin !== null && origin === pairing.origin;
 }
-// Each channel's Studio Analytics view (Advanced mode's Explore link with its chosen columns),
-// which the extension opens every day to export into Channels → YouTube. The start stays as
-// saved; the extension moves the end to today.
-export const studioExportViewPrefix = "studio.exportView.";
-export function exportViewProblem(url) {
-    let parsed;
-    try {
-        parsed = new URL(url.trim());
-    }
-    catch {
-        return "That isn't a link. In YouTube Studio, open Analytics → Advanced mode, set it up, and copy the address from the browser's address bar.";
-    }
-    if (parsed.origin !== "https://studio.youtube.com" ||
-        !/^\/channel\/UC[A-Za-z0-9_-]+\/analytics\/.+\/explore$/.test(parsed.pathname))
-        return "That isn't a Studio Analytics Advanced mode link. In YouTube Studio, open Analytics → Advanced mode, set it up, and copy the address from the browser's address bar.";
-    if (!parsed.searchParams.has("time_period"))
-        return "That link has no date range. In Advanced mode, pick the dates (the start stays as you set it; the end follows today), then copy the address again.";
-    return undefined;
-}
-export function readExportView(db, channelId) {
-    return readSetting(db, `${studioExportViewPrefix}${channelId}`) ?? null;
-}
-export function saveExportView(db, channelId, url) {
-    const key = `${studioExportViewPrefix}${channelId}`;
-    if (url === null || url.trim() === "")
-        db.prepare("DELETE FROM settings WHERE key = ?").run(key);
-    else
-        writeSetting(db, key, url.trim());
-}
-export function exportViews(db) {
-    const prefix = studioExportViewPrefix;
-    return db
-        .prepare("SELECT key, value FROM settings WHERE substr(key, 1, ?) = ? ORDER BY key")
-        .all(prefix.length, prefix).map((row) => ({ channelId: row.key.slice(prefix.length), url: row.value }));
-}

package/dist/slices/studio/stats.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+// Finished A/B tests as Studio shows them, read by the extension from the video's Analytics.
+// Slopify never asks YouTube's API: these are what Studio showed when the extension last looked.
 export const abVariantSchema = z.object({
     title: z.string().max(200).nullable(),
     // Which thumbnail (1-3) the variant showed, when Studio says.
@@ -8,40 +10,6 @@ export const abVariantSchema = z.object({
     winner: z.boolean(),
 });
 const slot = (short) => short ?? 0;
-const num = (value) => (typeof value === "number" ? value : null);
-export function saveStats(db, stats) {
-    db.prepare(`INSERT INTO video_stats(project_id,short,video_id,read_at,impressions,ctr,views,average_view_seconds,watch_hours)
-     VALUES (?,?,?,?,?,?,?,?,?) ON CONFLICT(project_id,short) DO UPDATE SET video_id=excluded.video_id,
-     read_at=excluded.read_at, impressions=excluded.impressions, ctr=excluded.ctr, views=excluded.views,
-     average_view_seconds=excluded.average_view_seconds, watch_hours=excluded.watch_hours`).run(stats.projectId, slot(stats.short), stats.videoId, stats.readAt, stats.impressions, stats.ctr, stats.views, stats.averageViewSeconds, stats.watchHours);
-}
-function statsOf(row) {
-    const short = Number(row.short);
-    return {
-        projectId: String(row.project_id),
-        short: short === 0 ? null : short,
-        videoId: String(row.video_id),
-        readAt: String(row.read_at),
-        impressions: num(row.impressions),
-        ctr: num(row.ctr),
-        views: num(row.views),
-        averageViewSeconds: num(row.average_view_seconds),
-        watchHours: num(row.watch_hours),
-    };
-}
-export function projectStats(db, projectId) {
-    return db
-        .prepare("SELECT * FROM video_stats WHERE project_id=? ORDER BY short")
-        .all(projectId)
-        .map(statsOf);
-}
-// Each project's long video's numbers, for the Projects list.
-export function longVideoStats(db) {
-    return new Map(db
-        .prepare("SELECT * FROM video_stats WHERE short=0")
-        .all()
-        .map((row) => [String(row.project_id), statsOf(row)]));
-}
 export function saveAbResult(db, result) {
     db.prepare(`INSERT INTO ab_results(project_id,short,video_id,read_at,variants) VALUES (?,?,?,?,?)
      ON CONFLICT(project_id,short) DO UPDATE SET video_id=excluded.video_id, read_at=excluded.read_at,

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.