@gentbajko/slopify 2.4.0 → 2.5.0

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

package/dist/slices/batch/index.js

@@ -48,6 +48,8 @@ export function enqueueBatch(deps, batchId, runs, retainStaged = false) {
             if (draft.sources.images === "provide")
                 for (const id of draft.provided.images ?? [])
                     used.add(id);
+            if (draft.shorts?.enabled === true && draft.provided.shortsMusic)
+                used.add(draft.provided.shortsMusic);
         }
         for (const id of retainStaged ? [] : used) {
             sources.add(id);

package/dist/slices/estimate/index.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { sourceOf } from "../admission/model.js";
-import { imageSecondsProblem, usesNarrationPreparation, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
+import { imageSecondsProblem, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
 import { chunkNarration, defaultChunking } from "../narration/chunk.js";
@@ -120,6 +120,14 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
         });
     if (images === 0)
         local("Images", "Provided or off.");
+    // The establishing image is one more image when it is made from a prompt.
+    if (usesReference(draft) && draft.reference?.source === "prompt")
+        requests.push({
+            kind: "image",
+            stage: "Establishing image",
+            provider: image.provider,
+            model: image.model,
+        });
     if (["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail))
         requests.push({
             kind: "image",

package/dist/slices/library/slots.js

@@ -2,7 +2,7 @@
 // the picked templates, the slot names they ask for, and the rendered text stored on the
 // project. The bodies are read at the click, not at selection, so an edit made in between
 // is the one that runs.
-import { normaliseDraft, usesNarrationPreparation, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
+import { normaliseDraft, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
 import { collectFields, render } from "../admission/substitute.js";
 import { snapshotEntry, snapshotPrompt } from "./snapshot.js";
 export function pickTemplates(db, input, snapshot) {
@@ -30,6 +30,10 @@ export function pickTemplates(db, input, snapshot) {
         body(db, "shorts", draft.shorts?.prompt, "shorts.prompt", missing, text, "shorts", snapshot);
         body(db, "image", draft.shorts?.imagePrompt, "shorts.imagePrompt", missing, image, "shortsImage", snapshot);
     }
+    // The establishing image's prompt: an image prompt like the others, its keywords filled the
+    // same way.
+    if (usesReference(draft) && draft.reference?.source === "prompt")
+        body(db, "image", draft.reference.prompt, "reference.prompt", missing, image, "referencePrompt", snapshot);
     if (sources.images === "generate") {
         for (const [index, picked] of draft.imagePrompts.entries()) {
             const field = `imagePrompts.${String(index)}.name`;
@@ -41,7 +45,9 @@ export function pickTemplates(db, input, snapshot) {
     if (sources.thumbnail === "from_prompt" || sources.thumbnail === "prompt_by_llm") {
         body(db, "thumbnail", draft.thumbnailPrompt, "thumbnailPrompt", missing, image, "thumbnailPrompt", snapshot);
     }
-    const fields = collectFields(text.map((picked) => picked.body), image.map((picked) => picked.body));
+    const fields = collectFields(
+    // The title's keywords are asked for like a prompt's: it is filled when the run starts.
+    [draft.title, ...text.map((picked) => picked.body)], image.map((picked) => picked.body));
     return {
         draft: withSavedModes(draft, intro, outro),
         requiredSlots: fields.map((field) => field.name),

package/dist/slices/library/snapshot.js

@@ -25,9 +25,15 @@ export const librarySnapshotSchema = z
 })
     .strict()
     .readonly();
+// A template names its prompts and intros/outros; the Library's current one of that name is
+// what a run from it uses, so editing a prompt reaches every template and schedule that names
+// it. The copy the template saved is only the fallback for one since deleted or renamed, so a
+// template never stops working because its Library changed.
 export function snapshotPrompt(db, snapshot, kind, name) {
-    return (snapshot?.prompts.find((row) => row.kind === kind && row.name.toLowerCase() === name.toLowerCase()) ?? promptByName(db, kind, name));
+    return (promptByName(db, kind, name) ??
+        snapshot?.prompts.find((row) => row.kind === kind && row.name.toLowerCase() === name.toLowerCase()));
 }
 export function snapshotEntry(db, snapshot, category, name) {
-    return (snapshot?.entries.find((row) => row.category === category && row.name.toLowerCase() === name.toLowerCase()) ?? entryByName(db, category, name));
+    return (entryByName(db, category, name) ??
+        snapshot?.entries.find((row) => row.category === category && row.name.toLowerCase() === name.toLowerCase()));
 }

package/dist/slices/notifications/notifier.js

@@ -0,0 +1,76 @@
+import { redact } from "../../kernel/log.js";
+import { noticeOf, noticeText, webhookBody } from "./rules.js";
+import { sendFailureText } from "./send.js";
+export function createRunNotifier(deps) {
+    // ceiling: one entry per project seen since boot, a few dozen bytes each.
+    const states = new Map();
+    const reasons = new Map();
+    const inflight = new Set();
+    let closed = false;
+    const notify = (projectId, kind) => {
+        const url = deps.url();
+        if (url === null)
+            return;
+        const subject = deps.subject(projectId);
+        if (subject === undefined)
+            return;
+        const text = noticeText(kind, { ...subject, reason: reasons.get(projectId) });
+        const body = redact(webhookBody(text));
+        const sending = deps
+            .send(url, body)
+            .then((result) => {
+            if (!result.ok)
+                deps.log.write("warn", "notification.failed", {
+                    projectId,
+                    detail: `${kind} notification not delivered: ${sendFailureText(result)}`,
+                });
+        })
+            .catch((error) => {
+            deps.log.write("warn", "notification.failed", {
+                projectId,
+                detail: `${kind} notification not delivered: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        })
+            .finally(() => {
+            inflight.delete(sending);
+        });
+        inflight.add(sending);
+    };
+    return {
+        observe: (event) => {
+            if (closed)
+                return;
+            try {
+                if (event.type === "stage.state") {
+                    if (event.state === "failed" && event.failureReason !== undefined)
+                        reasons.set(event.projectId, event.failureReason);
+                    else if (event.state === "running")
+                        reasons.delete(event.projectId);
+                    return;
+                }
+                if (event.type !== "project.state")
+                    return;
+                const previous = states.get(event.projectId);
+                if (previous === event.state)
+                    return;
+                states.set(event.projectId, event.state);
+                const kind = noticeOf(previous, event.state);
+                if (kind !== undefined)
+                    notify(event.projectId, kind);
+            }
+            catch (error) {
+                deps.log.write("warn", "notification.failed", {
+                    projectId: event.projectId,
+                    detail: `notification skipped: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        },
+        close: () => {
+            closed = true;
+        },
+        settled: async () => {
+            while (inflight.size > 0)
+                await Promise.all([...inflight]);
+        },
+    };
+}

package/dist/slices/notifications/rules.js

@@ -0,0 +1,81 @@
+// Only a run seen running can finish, fail or stop to wait: a project first seen already done
+// was done before anyone was watching. Paused and canceled are what the user just pressed, so
+// they say nothing. `pending` after `running` is the runner finding nothing it may start: a
+// review checkpoint holding the next step, or held work waiting for Resume.
+export function noticeOf(previous, next) {
+    if (previous !== "running")
+        return undefined;
+    switch (next) {
+        case "done":
+            return "ready";
+        case "failed":
+            return "failed";
+        case "pending":
+            return "waiting";
+        default:
+            return undefined;
+    }
+}
+const reasonMax = 140;
+// A provider's failure can run to paragraphs; a notification has a line.
+export function shortReason(reason) {
+    const line = reason
+        ?.split(/\r?\n/)
+        .map((part) => part.trim())
+        .find((part) => part !== "");
+    if (line === undefined)
+        return undefined;
+    return line.length <= reasonMax ? line : `${line.slice(0, reasonMax - 1).trimEnd()}…`;
+}
+export function noticeText(kind, subject) {
+    const title = subject.title.trim() === "" ? "Untitled project" : subject.title.trim();
+    switch (kind) {
+        case "ready":
+            return subject.makesVideo
+                ? { headline: `Video ready: ${title}`, detail: "Open the project to watch it." }
+                : { headline: `Run finished: ${title}`, detail: "Open the project to see its files." };
+        case "failed": {
+            const reason = shortReason(subject.reason);
+            return {
+                headline: reason === undefined ? `Run failed: ${title}` : `Run failed: ${title} — ${reason}`,
+                detail: "Open the project to see what stopped it and press Retry.",
+            };
+        }
+        case "waiting":
+            return {
+                headline: `Waiting for you: ${title}`,
+                detail: "Open the project to review the held step or press Resume.",
+            };
+    }
+}
+export const testNotice = {
+    headline: "Slopify test notification",
+    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you.",
+};
+// The body a Notification URL receives: plain text, which ntfy shows as the message. Nothing
+// but the project's title, what happened and the provider's own short reason goes in it.
+export function webhookBody(text) {
+    return `${text.headline}\n${text.detail}\n`;
+}
+export const notificationUrlMax = 2048;
+// Empty clears the setting. Otherwise one absolute http(s) URL with no user name or password:
+// fetch refuses those, and a password in a URL would sit in the database in plain sight.
+export function notificationUrlProblem(value) {
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return undefined;
+    if (trimmed.length > notificationUrlMax)
+        return `Keep the Notification URL to ${String(notificationUrlMax)} characters or fewer.`;
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return "Enter a full address starting with https:// or http://, for example https://ntfy.sh/your-topic.";
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:")
+        return "The Notification URL must start with https:// or http://.";
+    if (parsed.username !== "" || parsed.password !== "")
+        return "Remove the user name and password from the Notification URL; Slopify can't send them.";
+    return undefined;
+}

package/dist/slices/notifications/send.js

@@ -0,0 +1,40 @@
+// One POST to the user's Notification URL. Short, single-shot and never retried: a
+// notification that did not arrive is logged, and a run never waits on one.
+export const notificationTimeoutMs = 5_000;
+export function createNotificationSender(fetchImpl, timeoutMs = notificationTimeoutMs) {
+    return async (url, body) => {
+        try {
+            const response = await fetchImpl(url, {
+                method: "POST",
+                headers: { "content-type": "text/plain; charset=utf-8" },
+                body,
+                redirect: "manual",
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+            // The answer's body is never read; cancelling it frees the socket.
+            await response.body?.cancel().catch(() => { });
+            return response.ok ? { ok: true } : { ok: false, reason: "refused", status: response.status };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                reason: error instanceof DOMException &&
+                    (error.name === "TimeoutError" || error.name === "AbortError")
+                    ? "timeout"
+                    : "unreachable",
+            };
+        }
+    };
+}
+// What went wrong, in words fit for both the log and the Settings screen. The URL itself is
+// never repeated: an ntfy topic in it is as good as a password.
+export function sendFailureText(result) {
+    switch (result.reason) {
+        case "timeout":
+            return `the Notification URL didn't answer within ${String(notificationTimeoutMs / 1000)} seconds`;
+        case "unreachable":
+            return "the Notification URL couldn't be reached (wrong address, no network, or the server is down)";
+        case "refused":
+            return `the Notification URL answered HTTP ${String(result.status)}`;
+    }
+}