@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/backups/files.js

@@ -0,0 +1,135 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readdir, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+// Only files whose whole name matches these are this feature's. Pruning and the leftover sweep
+// touch nothing else in the folder: not an Export everything download
+// (slopify-backup-2026-09-27.tar), not a file the user renamed, not a symlink.
+const finalPattern = /^slopify-backup-(\d{4})-(\d{2})-(\d{2})T(\d{2})(\d{2})(\d{2})Z\.tar$/;
+const partialPattern = /^\.slopify-backup-\d{4}-\d{2}-\d{2}T\d{6}Z\.tar\.partial$/;
+export function backupFileName(at) {
+    const iso = at.toISOString();
+    return `slopify-backup-${iso.slice(0, 10)}T${iso.slice(11, 13)}${iso.slice(14, 16)}${iso.slice(17, 19)}Z.tar`;
+}
+export function isBackupFileName(name) {
+    return finalPattern.test(name);
+}
+function createdAtOf(name) {
+    const match = finalPattern.exec(name);
+    if (match === null)
+        return null;
+    const [, y, mo, d, h, mi, s] = match;
+    return `${y}-${mo}-${d}T${h}:${mi}:${s}.000Z`;
+}
+function partialName(name) {
+    return `.${name}.partial`;
+}
+export async function ensureFolder(folder) {
+    await mkdir(folder, { recursive: true, mode: 0o700 });
+    const stat = await lstat(folder);
+    if (!stat.isDirectory())
+        throw Object.assign(new Error("not a folder"), { code: "ENOTDIR" });
+}
+// Writes the archive under a hidden temporary name and renames it into place only after every
+// byte is on disk, so a crash, a full disk or a stop never leaves a file that looks like a
+// finished backup, and pruning never counts one.
+export async function writeAtomically(folder, name, chunks, signal) {
+    if (!isBackupFileName(name))
+        throw new Error(`${name} is not a backup file name.`);
+    const target = join(folder, name);
+    if ((await lstat(target).catch(() => undefined)) !== undefined)
+        throw Object.assign(new Error(`${name} already exists.`), { code: "EEXIST" });
+    const temporary = join(folder, partialName(name));
+    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0), 0o600);
+    let bytes = 0;
+    let renamed = false;
+    try {
+        for await (const chunk of chunks) {
+            signal?.throwIfAborted();
+            let written = 0;
+            while (written < chunk.byteLength) {
+                const result = await handle.write(chunk, written, chunk.byteLength - written);
+                written += result.bytesWritten;
+            }
+            bytes += chunk.byteLength;
+            // One turn of the event loop per chunk, so requests keep being answered while a large
+            // archive is written.
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        signal?.throwIfAborted();
+        await handle.sync();
+        await handle.close();
+        await rename(temporary, target);
+        renamed = true;
+        await syncFolder(folder);
+        return { path: target, bytes };
+    }
+    finally {
+        if (!renamed) {
+            await handle.close().catch(() => undefined);
+            await rm(temporary, { force: true }).catch(() => undefined);
+        }
+    }
+}
+async function syncFolder(folder) {
+    try {
+        const handle = await open(folder, constants.O_RDONLY);
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        // Some filesystems refuse fsync on a directory; the rename itself already happened.
+    }
+}
+// This feature's finished backups in the folder, oldest first. The time in the name orders
+// them, not the file's mtime, which a copy or a restore can change.
+export async function listBackups(folder) {
+    let names;
+    try {
+        names = await readdir(folder);
+    }
+    catch (error) {
+        if (codeOf(error) === "ENOENT")
+            return [];
+        throw error;
+    }
+    const out = [];
+    for (const name of names.filter(isBackupFileName).toSorted()) {
+        const stat = await lstat(join(folder, name)).catch(() => undefined);
+        const createdAt = createdAtOf(name);
+        if (stat?.isFile() !== true || createdAt === null)
+            continue;
+        out.push({ name, bytes: stat.size, createdAt });
+    }
+    return out;
+}
+// Deletes this feature's oldest backups until `keep` remain. Nothing else is ever removed.
+export async function pruneBackups(folder, keep) {
+    const files = await listBackups(folder);
+    const doomed = files.slice(0, Math.max(0, files.length - Math.max(1, keep)));
+    for (const file of doomed)
+        await rm(join(folder, file.name));
+    return doomed.map((file) => file.name);
+}
+// A partial file left by a crash or a power cut. Only called while no backup is being written.
+export async function removeLeftovers(folder) {
+    let removed = 0;
+    for (const name of await readdir(folder)) {
+        if (!partialPattern.test(name))
+            continue;
+        const stat = await lstat(join(folder, name)).catch(() => undefined);
+        if (stat?.isFile() !== true)
+            continue;
+        await rm(join(folder, name));
+        removed += 1;
+    }
+    return removed;
+}
+export function codeOf(error) {
+    return error instanceof Error && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+}

package/dist/slices/backups/folder.js

@@ -0,0 +1,43 @@
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { defaultBackupsDir } from "../storage/layout.js";
+export function effectiveFolder(paths, folder) {
+    return folder === null ? defaultBackupsDir(paths) : resolve(folder);
+}
+function within(root, path) {
+    const inside = relative(root, path);
+    return (inside === "" || (!inside.startsWith(`..${sep}`) && inside !== ".." && !isAbsolute(inside)));
+}
+// Why a chosen folder cannot hold backups, as the sentence the Folder field shows; undefined
+// when it can. Staging and logs are swept by Slopify itself, and the projects folder belongs to
+// storage reconciliation except for its Backups folder.
+export function folderProblem(paths, folder) {
+    if (folder === null)
+        return undefined;
+    if (!isAbsolute(folder))
+        return "Enter the folder's full path, starting from the top of the disk (for example /home/you/Slopify backups), or leave Folder empty to use the default.";
+    const path = resolve(folder);
+    if (within(paths.projects, path) && !within(defaultBackupsDir(paths), path))
+        return "This folder is inside Slopify's projects folder, which Slopify cleans up on its own. Pick a folder outside it, or leave Folder empty to use the default Backups folder.";
+    for (const own of [paths.staging, paths.logs, join(paths.dataDir, "models")])
+        if (within(own, path))
+            return "This folder is one Slopify uses for its own temporary files. Pick another folder, or leave Folder empty to use the default.";
+    return undefined;
+}
+// Where the folder is on the user's computer. In Docker only the projects folder (and, from
+// 3.0, the Backups folder) is shared with the host, so a folder elsewhere lives in the
+// container's private volume.
+export function hostFolder(paths, location, folder) {
+    if (!location.container)
+        return folder;
+    const shared = [
+        [paths.projects, location.hostProjects],
+        [paths.backups, location.hostBackups],
+    ];
+    for (const [inContainer, onHost] of shared.toSorted((a, b) => b[0].length - a[0].length)) {
+        if (!onHost || !within(inContainer, folder))
+            continue;
+        const inside = relative(inContainer, folder);
+        return inside === "" ? onHost : join(onHost, inside);
+    }
+    return null;
+}

package/dist/slices/backups/model.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { validTimeZone } from "../schedules/calendar.js";
+// Scheduled backups write the same archive Export everything downloads (storage/backup-export)
+// into a folder on disk, once a day, keeping the newest few. The settings table holds the
+// configuration and the last result under two keys no backup carries: exportableSettings
+// only lets known portable keys through, and a folder path belongs to this machine alone.
+export const configKey = "backups.config";
+export const statusKey = "backups.status";
+export const keepMin = 1;
+export const keepMax = 30;
+export const folderMax = 1024;
+const time = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Pick a time as HH:MM, 00:00 to 23:59.");
+export const backupConfigInputSchema = z
+    .object({
+    enabled: z.boolean(),
+    time,
+    timeZone: z
+        .string()
+        .min(1)
+        .max(64)
+        .refine(validTimeZone, "This time zone is not one Slopify knows."),
+    keep: z
+        .number()
+        .int()
+        .min(keepMin)
+        .max(keepMax, `Keep between ${keepMin} and ${keepMax} backups.`),
+    // null is the default folder, so moving the projects folder moves the backups with it.
+    folder: z.string().trim().min(1).max(folderMax).nullable(),
+})
+    .strict();
+export const storedConfigSchema = backupConfigInputSchema.extend({
+    // When the toggle was last turned on. A slot before it does not count, so turning backups on
+    // at 14:00 waits for tonight's 03:00 instead of starting a multi-gigabyte copy at once.
+    enabledAt: z.string().nullable(),
+});
+// Off by default, for new and existing installs alike: an archive holds every project's video
+// and can be many gigabytes, so filling a disk with copies is something the user asks for.
+export function defaultConfig(timeZone) {
+    return { enabled: false, time: "03:00", timeZone, keep: 5, folder: null, enabledAt: null };
+}
+export const triggers = ["scheduled", "catch-up", "manual"];
+export const backupStatusSchema = z.object({
+    lastAttemptAt: z.string().nullable(),
+    // "waiting": projects were being made, so the backup is held until they finish.
+    lastResult: z.enum(["succeeded", "failed", "waiting"]).nullable(),
+    lastTrigger: z.enum(triggers).nullable(),
+    // The slot the last attempt was for, so a failure is retried for that slot, not repeated.
+    lastSlot: z.string().nullable(),
+    detail: z.string().nullable(),
+    lastSuccessAt: z.string().nullable(),
+    lastSuccessFile: z.string().nullable(),
+    lastSuccessBytes: z.number().int().min(0).nullable(),
+    lastDurationMs: z.number().int().min(0).nullable(),
+});
+export const emptyStatus = {
+    lastAttemptAt: null,
+    lastResult: null,
+    lastTrigger: null,
+    lastSlot: null,
+    detail: null,
+    lastSuccessAt: null,
+    lastSuccessFile: null,
+    lastSuccessBytes: null,
+    lastDurationMs: null,
+};

package/dist/slices/backups/repo.js

@@ -0,0 +1,28 @@
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { backupStatusSchema, configKey, defaultConfig, emptyStatus, statusKey, storedConfigSchema, } from "./model.js";
+// A value this build cannot read (hand-edited, or written by a newer Slopify) falls back to
+// the default rather than stopping the app; the next save writes a good one.
+export function readConfig(db, fallbackTimeZone) {
+    const parsed = storedConfigSchema.safeParse(parseJson(readSetting(db, configKey)));
+    return parsed.success ? parsed.data : defaultConfig(fallbackTimeZone);
+}
+export function writeConfig(db, config) {
+    writeSetting(db, configKey, JSON.stringify(storedConfigSchema.parse(config)));
+}
+export function readStatus(db) {
+    const parsed = backupStatusSchema.safeParse(parseJson(readSetting(db, statusKey)));
+    return parsed.success ? parsed.data : emptyStatus;
+}
+export function writeStatus(db, status) {
+    writeSetting(db, statusKey, JSON.stringify(backupStatusSchema.parse(status)));
+}
+function parseJson(value) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/slices/backups/schedule.js

@@ -0,0 +1,60 @@
+import { nextOccurrence } from "../schedules/calendar.js";
+// After a start, the first backup waits this long so it never competes with the boot's own
+// work (migrations, reconcile, the queue resuming).
+export const startupDelayMs = 2 * 60_000;
+// A failed backup is tried again this often until the slot's backup succeeds or the next slot.
+export const retryAfterFailureMs = 60 * 60_000;
+// A backup held back by projects being made looks again this often.
+export const retryAfterWaitingMs = 10 * 60_000;
+// A slot missed while Slopify was off is made up for after the next start, unless a backup
+// already succeeded this recently ("about a day", with room for a slot that ran late).
+export const catchUpFreshMs = 20 * 60 * 60_000;
+// The most recent time-of-day slot at or before `now`, in the configured zone. Days are 23 to 25
+// hours long, so 26 hours back always holds at least one slot.
+export function latestSlot(time, timeZone, now) {
+    const daily = { kind: "daily", time };
+    let slot = nextOccurrence(daily, timeZone, new Date(now.valueOf() - 26 * 60 * 60_000));
+    if (slot === null || slot > now)
+        return null;
+    for (;;) {
+        const next = nextOccurrence(daily, timeZone, slot);
+        if (next === null || next > now)
+            return slot;
+        slot = next;
+    }
+}
+export function nextSlot(time, timeZone, now) {
+    return nextOccurrence({ kind: "daily", time }, timeZone, now);
+}
+// At most one automatic backup per daily slot. A slot is due once no backup has succeeded
+// since it; a slot that passed while Slopify was off is caught up after the next start.
+export function decideBackup(input) {
+    const { config, status, now, bootedAt } = input;
+    if (!config.enabled)
+        return { due: false, reason: "off" };
+    if (input.running)
+        return { due: false, reason: "running" };
+    const slot = latestSlot(config.time, config.timeZone, now);
+    if (slot === null)
+        return { due: false, reason: "not-yet" };
+    if (config.enabledAt !== null && slot.valueOf() < Date.parse(config.enabledAt))
+        return { due: false, reason: "not-yet" };
+    const lastSuccess = status.lastSuccessAt === null ? null : Date.parse(status.lastSuccessAt);
+    if (lastSuccess !== null && lastSuccess >= slot.valueOf())
+        return { due: false, reason: "done" };
+    const missed = bootedAt.valueOf() > slot.valueOf();
+    if (missed && lastSuccess !== null && now.valueOf() - lastSuccess < catchUpFreshMs)
+        return { due: false, reason: "done" };
+    if (now.valueOf() - bootedAt.valueOf() < startupDelayMs)
+        return { due: false, reason: "starting" };
+    if (status.lastSlot === slot.toISOString() && status.lastAttemptAt !== null) {
+        const wait = status.lastResult === "failed"
+            ? retryAfterFailureMs
+            : status.lastResult === "waiting"
+                ? retryAfterWaitingMs
+                : 0;
+        if (now.valueOf() - Date.parse(status.lastAttemptAt) < wait)
+            return { due: false, reason: "retry-later" };
+    }
+    return { due: true, slot: slot.toISOString(), trigger: missed ? "catch-up" : "scheduled" };
+}

package/dist/slices/backups/service.js

@@ -0,0 +1,311 @@
+import { statfs } from "node:fs/promises";
+import { BackupBusyError, planBackup, streamBackup, } from "../storage/backup-export.js";
+import { defaultBackupsDir } from "../storage/layout.js";
+import { backupFileName, codeOf, ensureFolder, listBackups, pruneBackups, removeLeftovers, writeAtomically, } from "./files.js";
+import { effectiveFolder, folderProblem, hostFolder } from "./folder.js";
+import { readConfig, readStatus, writeConfig, writeStatus } from "./repo.js";
+import { decideBackup, nextSlot } from "./schedule.js";
+// Scheduled backups reuse Export everything's own code path (planBackup, streamBackup) and so
+// its rule too: nothing is copied while a project is being made, because its files are still
+// being written. A backup that meets one waits and looks again, so it never competes with a
+// render; the writing itself yields to the event loop after every chunk.
+export function createBackupService(deps) {
+    let current;
+    let stopped = false;
+    const zone = deps.serverTimeZone ?? (Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC");
+    const config = () => readConfig(deps.db, zone);
+    const folderOf = (value) => effectiveFolder(deps.paths, value.folder);
+    const record = (status) => {
+        try {
+            writeStatus(deps.db, status);
+        }
+        catch (error) {
+            deps.log.write("error", "backups.status", { detail: String(error) });
+        }
+    };
+    const start = (plan, trigger, slot, release) => {
+        const abort = new AbortController();
+        const done = write(plan, trigger, slot, abort.signal)
+            .catch((error) => {
+            deps.log.write("error", "backups.run", { detail: String(error) });
+        })
+            .finally(() => {
+            release();
+            current = undefined;
+        });
+        current = { abort, done };
+        return done;
+    };
+    async function write(plan, trigger, slot, signal) {
+        const settings = config();
+        const folder = folderOf(settings);
+        const startedAt = deps.clock.now();
+        const previous = readStatus(deps.db);
+        const attempt = {
+            ...previous,
+            lastAttemptAt: startedAt.toISOString(),
+            lastTrigger: trigger,
+            lastSlot: slot,
+        };
+        try {
+            await ensureFolder(folder);
+            await removeLeftovers(folder);
+            await checkSpace(folder, plan.archiveBytes);
+            const name = backupFileName(startedAt);
+            const written = await writeAtomically(folder, name, streamBackup(plan), signal);
+            let detail = null;
+            try {
+                await pruneBackups(folder, settings.keep);
+            }
+            catch (error) {
+                deps.log.write("warn", "backups.prune", { detail: String(error) });
+                detail = `The backup was saved, but older backups in ${folder} could not be removed (${codeOf(error) ?? "unknown error"}), so more than ${settings.keep} are kept. Check Slopify can delete files in that folder, or pick another Folder in Settings → Backups.`;
+            }
+            record({
+                ...attempt,
+                lastResult: "succeeded",
+                detail,
+                lastSuccessAt: deps.clock.now().toISOString(),
+                lastSuccessFile: written.path,
+                lastSuccessBytes: written.bytes,
+                lastDurationMs: deps.clock.now().valueOf() - startedAt.valueOf(),
+            });
+        }
+        catch (error) {
+            deps.log.write("error", "backups.run", { detail: String(error) });
+            record({
+                ...attempt,
+                lastResult: "failed",
+                detail: explain(error, folder, trigger !== "manual", signal),
+                lastDurationMs: deps.clock.now().valueOf() - startedAt.valueOf(),
+            });
+        }
+    }
+    const waiting = (projects, trigger, slot) => {
+        record({
+            ...readStatus(deps.db),
+            lastAttemptAt: deps.clock.now().toISOString(),
+            lastResult: "waiting",
+            lastTrigger: trigger,
+            lastSlot: slot,
+            detail: `Waiting for ${named(projects)} to finish: a backup never copies a project while its files are being written. It starts by itself when they finish or are paused.`,
+            lastDurationMs: null,
+        });
+    };
+    return {
+        view: async () => {
+            const settings = config();
+            const folder = folderOf(settings);
+            const now = deps.clock.now();
+            let files = [];
+            try {
+                files = await listBackups(folder);
+            }
+            catch {
+                files = [];
+            }
+            const decision = decideBackup({
+                config: settings,
+                status: readStatus(deps.db),
+                now,
+                bootedAt: deps.bootedAt,
+                running: current !== undefined,
+            });
+            const overdue = decision.due || (!decision.due && ["starting", "retry-later"].includes(decision.reason));
+            return {
+                config: {
+                    enabled: settings.enabled,
+                    time: settings.time,
+                    timeZone: settings.timeZone,
+                    keep: settings.keep,
+                    folder: settings.folder,
+                },
+                folder,
+                defaultFolder: defaultBackupsDir(deps.paths),
+                hostFolder: hostFolder(deps.paths, deps.location, folder),
+                container: deps.location.container,
+                running: current !== undefined,
+                nextRunAt: settings.enabled
+                    ? (nextSlot(settings.time, settings.timeZone, now)?.toISOString() ?? null)
+                    : null,
+                overdue: settings.enabled && overdue,
+                status: readStatus(deps.db),
+                files,
+            };
+        },
+        save: (input) => {
+            const problem = folderProblem(deps.paths, input.folder);
+            if (problem !== undefined)
+                return { ok: false, detail: problem };
+            const before = config();
+            const now = deps.clock.now().toISOString();
+            const moved = before.time !== input.time || before.timeZone !== input.timeZone;
+            const enabledAt = !input.enabled
+                ? null
+                : !before.enabled || moved || before.enabledAt === null
+                    ? now
+                    : before.enabledAt;
+            writeConfig(deps.db, { ...input, enabledAt });
+            return { ok: true };
+        },
+        runNow: () => {
+            if (stopped)
+                return {
+                    ok: false,
+                    status: 409,
+                    detail: "Slopify is shutting down. Start it again, then press Back up now.",
+                };
+            if (current !== undefined)
+                return {
+                    ok: false,
+                    status: 409,
+                    detail: "A backup is already being written. Wait for it to finish; its result shows here.",
+                };
+            const problem = folderProblem(deps.paths, config().folder);
+            if (problem !== undefined)
+                return { ok: false, status: 400, detail: problem };
+            const release = deps.beginMutation === undefined ? () => { } : deps.beginMutation();
+            if (release === undefined)
+                return busyUpdating();
+            let plan;
+            try {
+                plan = planBackup(deps);
+            }
+            catch (error) {
+                release();
+                if (error instanceof BackupBusyError)
+                    return {
+                        ok: false,
+                        status: 409,
+                        detail: `Slopify can't back up while ${named(error.projects)} ${error.projects.length === 1 ? "is" : "are"} being made: their files are still being written. Wait for them to finish, or pause them on their project page, then press Back up now again.`,
+                    };
+                throw error;
+            }
+            void start(plan, "manual", null, release);
+            return { ok: true };
+        },
+        tick: async () => {
+            if (stopped || current !== undefined)
+                return;
+            const settings = config();
+            const decision = decideBackup({
+                config: settings,
+                status: readStatus(deps.db),
+                now: deps.clock.now(),
+                bootedAt: deps.bootedAt,
+                running: false,
+            });
+            if (!decision.due)
+                return;
+            if (folderProblem(deps.paths, settings.folder) !== undefined)
+                return;
+            const release = deps.beginMutation === undefined ? () => { } : deps.beginMutation();
+            // An update is being installed; the backup runs after the restart.
+            if (release === undefined)
+                return;
+            let plan;
+            try {
+                plan = planBackup(deps);
+            }
+            catch (error) {
+                release();
+                if (error instanceof BackupBusyError) {
+                    waiting(error.projects, decision.trigger, decision.slot);
+                    return;
+                }
+                deps.log.write("error", "backups.plan", { detail: String(error) });
+                record({
+                    ...readStatus(deps.db),
+                    lastAttemptAt: deps.clock.now().toISOString(),
+                    lastResult: "failed",
+                    lastTrigger: decision.trigger,
+                    lastSlot: decision.slot,
+                    detail: "The backup was not saved because Slopify could not read what to back up. It tries again in an hour; if it keeps failing, use Download diagnostics in Settings and report it.",
+                    lastDurationMs: null,
+                });
+                return;
+            }
+            await start(plan, decision.trigger, decision.slot, release);
+        },
+        stop: async () => {
+            stopped = true;
+            const running = current;
+            if (running === undefined)
+                return;
+            running.abort.abort(new Error("Slopify is stopping."));
+            await running.done;
+        },
+    };
+}
+function busyUpdating() {
+    return {
+        ok: false,
+        status: 409,
+        detail: "Slopify is installing an update. Press Back up now again after it restarts.",
+    };
+}
+async function checkSpace(folder, needed) {
+    let free;
+    try {
+        const stats = await statfs(folder);
+        free = Number(stats.bavail) * Number(stats.bsize);
+    }
+    catch {
+        return;
+    }
+    if (free < needed)
+        throw new NoSpaceError(needed, free);
+}
+class NoSpaceError extends Error {
+    needed;
+    free;
+    constructor(needed, free) {
+        super("Not enough free space for the backup.");
+        this.needed = needed;
+        this.free = free;
+    }
+}
+function named(projects) {
+    const titles = projects
+        .slice(0, 3)
+        .map((project) => `"${project.title}"`)
+        .join(", ");
+    return projects.length > 3 ? `${titles} and ${projects.length - 3} more` : titles;
+}
+// What failed, why, and what to change - the sentence Settings → Backups shows.
+export function explain(error, folder, retries, signal) {
+    const fix = "Pick another Folder in Settings → Backups, or leave it empty to use the default";
+    if (signal?.aborted === true && error === signal.reason)
+        return "The backup was not saved: Slopify stopped while writing it, and the unfinished file was removed. It runs again after Slopify starts.";
+    if (error instanceof NoSpaceError)
+        return `The backup was not saved: it needs about ${bytes(error.needed)}, but the disk holding ${folder} has ${bytes(error.free)} free. Free up space there, lower "Keep last" in Settings → Backups, or pick another Folder.`;
+    switch (codeOf(error)) {
+        case "ENOSPC":
+        case "EDQUOT":
+            return `The backup was not saved: the disk holding ${folder} ran out of space. Free up space there, lower "Keep last" in Settings → Backups, or pick another Folder.`;
+        case "EACCES":
+        case "EPERM":
+        case "EROFS":
+            return `The backup was not saved: Slopify is not allowed to write to ${folder}. ${fix}.`;
+        case "ENOTDIR":
+        case "EEXIST":
+            return `The backup was not saved: ${folder} (or a part of its path) is a file, not a folder. ${fix}.`;
+    }
+    const again = retries
+        ? "It tries again within the hour, or press Back up now"
+        : "Press Back up now to try again";
+    if (error instanceof Error &&
+        error.message.endsWith("changed while the backup was being written."))
+        return `The backup was not saved: a project file changed while it was being copied. ${again}.`;
+    return `The backup was not saved because of an unexpected error. ${again}; if it keeps failing, use Download diagnostics in Settings and report it.`;
+}
+function bytes(value) {
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let amount = value;
+    let unit = 0;
+    while (amount >= 1024 && unit < units.length - 1) {
+        amount /= 1024;
+        unit += 1;
+    }
+    return `${amount >= 10 || unit === 0 ? amount.toFixed(0) : amount.toFixed(1)} ${units[unit]}`;
+}