@gentbajko/slopify 2.4.0 → 2.5.0

package/dist/main.js

@@ -12,7 +12,7 @@ import { nodeRunCli } from "./adapters/llm/run-cli.js";
 import { curateRegistry } from "./catalog/registry.js";
 import { createCatalogueStore } from "./catalog/store.js";
 import { dockerActivationCommitted, dockerFolderConfiguration, } from "./edge/docker-projects/activation.js";
-import { createHub } from "./edge/events/hub.js";
+import { createHub, observedHub } from "./edge/events/hub.js";
 import { currentProjectEvent } from "./edge/events/visibility.js";
 import { createApp } from "./edge/http/app.js";
 import { createMutationLifecycle, drainMutationsWithDeadline } from "./edge/http/mutations.js";
@@ -36,11 +36,15 @@ import { stageProviders } from "./kernel/runner/providers.js";
 import { createProviderQueue } from "./kernel/runner/queue.js";
 import { readVersion } from "./kernel/version.js";
 import { modelSources } from "./model-catalog.js";
-import { projectPaused } from "./slices/admission/repo.js";
+import { projectById, projectPaused } from "./slices/admission/repo.js";
+import { createBackupService } from "./slices/backups/service.js";
 import { pumpQueue, queueWaiting } from "./slices/batch/index.js";
 import { approveCheckpoint } from "./slices/checkpoints/index.js";
 import { checkpointDecisionForWork, recoverCheckpointWork, settleReleasedCheckpoints, } from "./slices/checkpoints/recovery.js";
 import { resolveFont } from "./slices/fonts/index.js";
+import { createRunNotifier } from "./slices/notifications/notifier.js";
+import { createNotificationSender } from "./slices/notifications/send.js";
+import { readNotificationUrl } from "./slices/notifications/settings.js";
 import { templateById } from "./slices/project-templates/repo.js";
 import { claimWork, finishWork, maySubmit } from "./slices/rebuild/repo.js";
 import { materializeAdmittedWork } from "./slices/rebuild/runtime-materialize.js";
@@ -49,7 +53,7 @@ import { executionStages, executionStandings, invocationReady, projectStandings,
 import { settleTerminalScheduleRuns } from "./slices/schedules/repo.js";
 import { createScheduleRunner } from "./slices/schedules/scheduler.js";
 import { nodeCliProbe } from "./slices/settings/cli-status.js";
-import { isLocalCliProvider } from "./slices/settings/model.js";
+import { isLocalCliProvider, localCliConcurrency } from "./slices/settings/model.js";
 import { providerStatuses } from "./slices/settings/readiness.js";
 import { reconcileStorage } from "./slices/storage/reconcile.js";
 import { collectorEndpoint, httpPostEvents } from "./slices/telemetry/collector-client.js";
@@ -151,11 +155,23 @@ export async function boot(config, options = {}) {
                 : `interrupted stages ${interrupted}, settled schedules ${settledSchedules}, orphan files ${reconciled.orphanFiles}, staged files ${reconciled.stagedFiles}`,
         });
         const eventDb = db;
-        const hub = createHub({
+        const sendNotification = createNotificationSender(globalThis.fetch);
+        const notifier = createRunNotifier({
+            url: () => readNotificationUrl(eventDb),
+            subject: (projectId) => {
+                const project = projectById(eventDb, projectId);
+                return project === undefined
+                    ? undefined
+                    : { title: project.title, makesVideo: project.config.sources.video !== "off" };
+            },
+            send: sendNotification,
+            log,
+        });
+        const hub = observedHub(createHub({
             ids,
             log,
             acceptEvent: (event) => currentProjectEvent(eventDb, event),
-        });
+        }), notifier.observe);
         const version = readVersion();
         const telemetry = { db, ids, clock, log, appVersion: version };
         const flusher = createFlusher({
@@ -319,14 +335,28 @@ export async function boot(config, options = {}) {
             }),
         });
         const mutations = createMutationLifecycle();
+        const folderConfiguration = await dockerFolderConfiguration(process.env, paths.projects);
+        const backups = createBackupService({
+            db,
+            paths,
+            clock,
+            ids,
+            log,
+            appVersion: version,
+            hasInflight: runner.hasInflight,
+            location: folderConfiguration,
+            bootedAt: clock.now(),
+            beginMutation: updater.beginMutation,
+        });
         const app = createApp({
             rebuild,
             drafts: draftDeps,
             schedules: scheduleDeps,
+            backups,
             ...(rebuild.measureAudio === undefined ? {} : { measureAudio: rebuild.measureAudio }),
             openFolder,
             folderLocation: {
-                ...(await dockerFolderConfiguration(process.env, paths.projects)),
+                ...folderConfiguration,
                 ...(hostCli === undefined ? {} : { openOnHost: hostCli.openFolder }),
             },
             ...(dockerState === undefined ? {} : { installationPending: () => updater.locked() }),
@@ -336,6 +366,7 @@ export async function boot(config, options = {}) {
             runner,
             updater,
             mutations,
+            sendNotification,
             audioPreviews,
             ...modelSources(registry),
             catalogue,
@@ -367,6 +398,13 @@ export async function boot(config, options = {}) {
             void scheduleTicks.tick();
         }, 15_000);
         void scheduleTicks.tick();
+        // Once a minute is plenty for a daily slot; the decision itself (slices/backups/schedule)
+        // holds the first run back for a couple of minutes after a start.
+        const backupTimer = setInterval(() => {
+            backups.tick().catch((error) => {
+                log.write("error", "backups.tick", { detail: causedBy(error) });
+            });
+        }, 60_000);
         listeningPort = portOf(server) ?? config.port;
         // Whatever last run left queued goes out at start. Nothing waits for
         // it, and an unreachable collector costs one refused socket.
@@ -388,10 +426,14 @@ export async function boot(config, options = {}) {
         let stopActivation = () => { };
         shutdown = () => {
             stopping ??= (async () => {
+                notifier.close();
                 clearInterval(queueTimer);
                 clearInterval(scheduleTimer);
+                clearInterval(backupTimer);
                 const mutationDrain = mutations.stop();
                 const scheduleDrain = scheduleTicks.stop();
+                // A backup being written is stopped and its partial file removed, not waited for.
+                const backupDrain = backups.stop();
                 const serverClose = beginServerClose(server);
                 stopActivation();
                 audioPreviews.close();
@@ -401,6 +443,7 @@ export async function boot(config, options = {}) {
                     // database until their response settles; anything racing shutdown receives 503.
                     await drainMutationsWithDeadline(mutationDrain, serverClose.terminate, mutationDrainTimeoutMs);
                     await scheduleDrain;
+                    await backupDrain;
                     await runner.abortAll();
                 }
                 finally {
@@ -449,7 +492,9 @@ export function wireRunner({ audioPreviews, db, paths, clock, ids, log, hub, tel
         attempts: sqliteAttempts(db, ids),
         clock,
         log,
-        queue: createProviderQueue((provider) => isLocalCliProvider(provider) ? 3 : (catalogue.read().providers[provider]?.maxConcurrent ?? 1)),
+        queue: createProviderQueue((provider) => isLocalCliProvider(provider)
+            ? localCliConcurrency(provider)
+            : (catalogue.read().providers[provider]?.maxConcurrent ?? 1)),
     };
     const checkpoints = createCheckpointAuthority({
         decide: (work) => checkpointDecisionForWork(execution, work),

package/dist/slices/admission/model.js

@@ -10,3 +10,11 @@ export function sourceOf(sources, kind) {
 // Mix of both taking turns, or Still. `video/motion.ts` has the rules.
 export const motionStyles = ["zoom", "pan", "mixed", "still"];
 export const entryModes = ["text", "llm"];
+// The Images stage's establishing image: made first (from a library image prompt) or uploaded,
+// then every other image of the run - the video's, the shorts' and, unless `thumbnail` is
+// false, the thumbnail - is drawn with it as a visual reference for characters, style and
+// palette. It is never shown in the video. Absent is Off, which is what every project saved
+// before it existed was.
+export const referenceSources = ["prompt", "provide"];
+// The work key of the establishing image's step, in the Images stage.
+export const referenceKey = "reference:image";

package/dist/slices/admission/rules.js

@@ -125,6 +125,9 @@ export function admit(input) {
     fields.push(...youtubeDescriptionFields(draft));
     fields.push(...shortsFields(draft));
     fields.push(...videoEditFields(draft));
+    fields.push(...referenceFields(draft));
+    if (usesReference(draft) && draft.reference?.source === "provide")
+        checkFile(input.staged, draft.provided.reference, "images", "provided.reference", "Upload the establishing image, or set Establishing image to Off in the Images section.", fields);
     checkProvided(draft, input.staged, fields);
     checkValues(draft, input.requiredSlots, fields);
     if (!Number.isFinite(draft.silenceGapSeconds) ||
@@ -243,6 +246,26 @@ function checkProvided(draft, staged, fields) {
             checkFile(staged, id, "images", `provided.images.${index}`, "Pick an image.", fields);
         }
     }
+    checkShortsMusic(draft, staged, fields);
+}
+// The shorts' background music is optional, so only a file that was picked is checked, and
+// only while Shorts is on. Named by where the control sits: Play's Export rail.
+function checkShortsMusic(draft, staged, fields) {
+    const id = draft.provided.shortsMusic;
+    if (draft.shorts?.enabled !== true || id === undefined)
+        return;
+    const where = "under Outputs → Export → More shorts options → Background music";
+    const file = staged.find((candidate) => candidate.id === id);
+    if (file === undefined || file.stageKind !== "audio")
+        fields.push({
+            field: "shorts.music",
+            message: `The shorts' background music file is no longer available, so it can't be added to the project. Choose the file again ${where}, or remove it.`,
+        });
+    else if (file.state !== "staged")
+        fields.push({
+            field: "shorts.music",
+            message: `The shorts' background music is still uploading, so the run can't start yet. Wait for it to finish, or remove it ${where}.`,
+        });
 }
 // A run never starts with provided content that is missing or still copying.
 function checkFile(staged, id, kind, field, missing, fields) {
@@ -312,6 +335,30 @@ export function youtubeDescriptionFields(draft) {
         ]
         : [];
 }
+// The establishing image belongs to the Images stage: it is made, and the images drawn with
+// it, only while images are Generate.
+export function usesReference(draft) {
+    return draft.reference !== undefined && draft.sources.images === "generate";
+}
+// Whether the thumbnail is drawn with it too: on unless turned off, and only for a thumbnail
+// the image provider makes.
+export function referenceForThumbnail(draft) {
+    return (usesReference(draft) &&
+        draft.reference?.thumbnail !== false &&
+        (draft.sources.thumbnail === "from_prompt" || draft.sources.thumbnail === "prompt_by_llm"));
+}
+export function referenceFields(draft) {
+    return usesReference(draft) &&
+        draft.reference?.source === "prompt" &&
+        (draft.reference.prompt === undefined || draft.reference.prompt.trim() === "")
+        ? [
+            {
+                field: "reference.prompt",
+                message: "Pick an image prompt for the establishing image, upload one instead, or set Establishing image to Off in the Images section.",
+            },
+        ]
+        : [];
+}
 // Shorts are cut from the narration and captioned from its word timings, so they need
 // narration, like the YouTube description; they run whether the video renders or not.
 export function usesShorts(draft) {

package/dist/slices/admission/schema.js

@@ -5,7 +5,7 @@ import { documentSettingsSchema } from "../document/theme-schema.js";
 import { chunkModes } from "../narration/chunk.js";
 import { subtitleConfigSchema } from "../subtitles/model.js";
 import { animateModes, atmospheres, colorGrades, cutModes, lookLevels, transitionKinds, } from "../video/edit-settings.js";
-import { entryModes, formats, motionStyles, stageSources } from "./model.js";
+import { entryModes, formats, motionStyles, referenceSources, stageSources } from "./model.js";
 import { defaultEdgeSilenceSeconds, defaultImageSeconds, defaultMotionStyle, defaultZoomPercent, } from "./rules.js";
 const providerChoice = z.object({
     provider: z.string(),
@@ -66,6 +66,13 @@ export const runDraftSchema = z.object({
         .readonly()
         .optional(),
     images: providerChoice.optional(),
+    reference: z
+        .object({
+        source: z.enum(referenceSources),
+        prompt: z.string().optional(),
+        thumbnail: z.boolean().optional(),
+    })
+        .optional(),
     articlePrompt: z.string().optional(),
     narrationPrompt: z.string().optional(),
     imagePrompts: z.array(z.object({ name: z.string(), number: z.number() })),
@@ -79,6 +86,9 @@ export const runDraftSchema = z.object({
         audio: z.string().optional(),
         images: z.array(z.string()).optional(),
         thumbnail: z.string().optional(),
+        reference: z.string().optional(),
+        // The staged file of the shorts' background music; used only while Shorts is on.
+        shortsMusic: z.string().optional(),
     }),
     // Optional until Play carries the control; unknown keys are stripped by this schema, so
     // a mode not listed here would never reach the audio stage.

package/dist/slices/admission/start.js

@@ -5,11 +5,15 @@ import { defaultDocumentTheme } from "../document/model.js";
 import { collectSharedGlossary } from "../narration/shared-glossary.js";
 import { admitInitialRevision } from "../rebuild/runtime-admission.js";
 import { adoptBaseline } from "../revisions/adopt.js";
+import { insertAsset } from "../revisions/repo.js";
+import { discardPreparedAssets } from "../storage/assets.js";
+import { prepareStagedFile } from "../storage/prepare.js";
 import { attachStagedFile, storeText } from "../storage/staging.js";
 import { releaseStagedFile } from "../storage/staging-refs.js";
 import { sourceOf, } from "./model.js";
 import { insertProject, insertStage } from "./repo.js";
-import { usesPronunciationGlossary } from "./rules.js";
+import { usesPronunciationGlossary, usesReference } from "./rules.js";
+import { render } from "./substitute.js";
 // Provide → `provided` with its output attached; Off → `skipped`;
 // everything else → `pending`.
 export function initialState(source) {
@@ -26,8 +30,12 @@ export function startRun(deps, draft, rendered, retainStaged = false, templates)
     const shared = usesPronunciationGlossary(draft) && draft.audio?.shareGlossary === true
         ? collectSharedGlossary(deps).entries
         : [];
+    // The title may name keywords too ("D&D Lore: {{Topic}}"), filled like a prompt's, so a
+    // template or Play keeps the pattern and each project gets its own title.
+    const title = render(draft.title, draft.values).trim() || draft.title;
     const config = {
         ...draft,
+        title,
         // A new project always names its document theme: a config without one reads as the
         // DiceMaster of older projects (see documentThemeOf), which no new project should get.
         ...(sourceOf(draft.sources, "document") === "generate" && draft.document === undefined
@@ -38,7 +46,7 @@ export function startRun(deps, draft, rendered, retainStaged = false, templates)
     };
     const project = {
         id,
-        title: draft.title,
+        title,
         format: draft.format,
         config,
         createdAt: at,
@@ -63,19 +71,32 @@ export function startRun(deps, draft, rendered, retainStaged = false, templates)
     // the project folder rather than moved, so a rollback leaves the staging files exactly
     // as the form left them and the same Play can simply be pressed again.
     const moved = [];
-    transact(deps.db, () => {
-        insertProject(deps.db, project);
-        for (const stage of stages) {
-            insertStage(deps.db, stage);
-        }
-        attachProvided(deps, id, draft, moved, retainStaged);
-        if (deps.catalogue !== undefined) {
-            const baseline = adoptBaseline(deps, id, templates);
-            if (!baseline.ok)
-                throw new Error("The new project has no revision.");
-            admitInitialRevision(deps, baseline.view, deps.catalogue.read());
-        }
-    });
+    let music;
+    try {
+        transact(deps.db, () => {
+            insertProject(deps.db, project);
+            for (const stage of stages) {
+                insertStage(deps.db, stage);
+            }
+            attachProvided(deps, id, draft, moved, retainStaged);
+            music = attachShortsMusic(deps, id, draft, moved);
+            // The music is named by the first revision, as Edit project → Shorts names it, so the
+            // project gets its revision now even where it would otherwise wait for its first view.
+            if (deps.catalogue !== undefined || music !== undefined) {
+                const baseline = adoptBaseline(deps, id, templates, music === undefined ? {} : { shortsMusic: music.id });
+                if (!baseline.ok)
+                    throw new Error("The new project has no revision.");
+                if (deps.catalogue !== undefined)
+                    admitInitialRevision(deps, baseline.view, deps.catalogue.read());
+            }
+        });
+    }
+    catch (error) {
+        // The copy was written outside the transaction; nothing names it once it rolled back.
+        if (music !== undefined)
+            discardPreparedAssets(deps, [music]);
+        throw error;
+    }
     for (const source of retainStaged ? [] : moved) {
         releaseStagedFile(deps, source);
     }
@@ -103,6 +124,9 @@ function attachProvided(deps, projectId, draft, collected, retainStaged) {
     if (sources.thumbnail === "provide") {
         attach(deps, projectId, "thumbnail", provided.thumbnail, "thumbnail", collected, retainStaged);
     }
+    if (usesReference(draft) && draft.reference?.source === "provide") {
+        attach(deps, projectId, "images", provided.reference, "reference", collected, retainStaged);
+    }
     if (sources.images === "provide") {
         // Slideshow order is the order the user left the list in.
         for (const [index, stagedFileId] of (provided.images ?? []).entries()) {
@@ -110,6 +134,20 @@ function attachProvided(deps, projectId, draft, collected, retainStaged) {
         }
     }
 }
+// The Shorts step's background music, copied into the project as an asset of its own (never
+// an output), exactly as Edit project → Shorts keeps an uploaded one. Only while Shorts is on.
+function attachShortsMusic(deps, projectId, draft, collected) {
+    const stagedFileId = draft.provided.shortsMusic;
+    if (draft.shorts?.enabled !== true || stagedFileId === undefined)
+        return undefined;
+    const result = prepareStagedFile(deps, { projectId, stagedFileId, role: "audio_body" });
+    if (!result.ok)
+        // admit() already refused a missing or still-copying file, as for the stages' own files.
+        throw new Error(`the shorts' background music could not be attached: ${result.reason}`);
+    insertAsset(deps.db, result.asset);
+    collected.push(stagedFileId);
+    return result.asset;
+}
 function attach(deps, projectId, kind, stagedFileId, role, collected, retainStaged, index) {
     if (stagedFileId === undefined) {
         throw new Error(`the ${kind} stage is provided but carries no staged file`);

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,35 @@
+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 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;
+    if (location.hostProjects === null || !within(paths.projects, folder))
+        return null;
+    const inside = relative(paths.projects, folder);
+    return inside === "" ? location.hostProjects : join(location.hostProjects, inside);
+}

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;
+    }
+}