@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/edge/http/studio.js

@@ -0,0 +1,207 @@
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { findDownload } from "../../slices/storage/downloads.js";
+import { studioPlaylistMax } from "../../slices/studio/model.js";
+import { packItem, uploadPack } from "../../slices/studio/pack.js";
+import { bearerToken, isExtensionOrigin, pairStudioExtension, readStudioPlaylist, resetStudioPairing, saveRealFootage, saveStudioPlaylist, studioPairing, studioPlaylistProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+const projectParam = z.object({ projectId: id });
+const fileParam = z.object({
+    projectId: id,
+    asset: z
+        .string()
+        .max(64)
+        .regex(/^[a-z0-9-]+$/),
+});
+const chooseBody = z.object({ short: z.number().int().min(1).max(99).optional() });
+const playlistBody = z.object({ playlist: z.string().max(studioPlaylistMax * 2) });
+const realFootageBody = z.object({ realFootage: z.boolean() });
+// How long a "Fill in YouTube Studio" choice stays the one the extension fills in.
+const choiceMs = 6 * 60 * 60 * 1000;
+// The Studio routes. The ones under `/ext` are the only routes of the app a page from another
+// origin may read, and only the paired browser extension: every request carries the pairing
+// token, and the CORS headers name the paired extension's origin, never a web page's and never
+// `*`. The rest are the Slopify page's own, refused from any other origin.
+export function studioRoutes(deps) {
+    // What the person chose to fill in last; kept in memory, so a restart asks them to choose
+    // again rather than filling in an old choice.
+    let chosen;
+    const samePage = (c) => {
+        const origin = c.req.header("origin");
+        if (origin === undefined || origin === new URL(c.req.url).origin)
+            return undefined;
+        return problem(c, {
+            status: 403,
+            title: titleOf(403),
+            detail: "For your safety, YouTube Studio settings can only be changed from the Slopify page itself. Open Slopify and try again there.",
+        });
+    };
+    // The CORS headers for the extension: its own origin, echoed only when it is allowed.
+    const allowOrigin = (c, pairing) => {
+        const origin = c.req.header("origin");
+        const paired = studioPairing(deps.db).origin;
+        c.header("Vary", "Origin");
+        if (!isExtensionOrigin(origin))
+            return;
+        if (origin === paired || pairing) {
+            c.header("Access-Control-Allow-Origin", origin);
+            c.header("Access-Control-Allow-Headers", "authorization, content-type");
+            c.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+            c.header("Access-Control-Max-Age", "600");
+        }
+    };
+    const refused = (c) => problem(c, {
+        status: 401,
+        title: "Unauthorized",
+        detail: "The Slopify Studio extension isn't paired with this Slopify. Copy the pairing token from Slopify's Settings → YouTube Studio into the extension's options and press Pair.",
+    });
+    return (new Hono()
+        .get("/settings", (c) => {
+        // The token is read only by the Slopify page, never by another origin's.
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        return c.json({ playlist: readStudioPlaylist(deps.db), pairing: studioPairing(deps.db) });
+    })
+        .put("/settings/playlist", zValidator("json", playlistBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const raw = c.req.valid("json").playlist;
+        const invalid = studioPlaylistProblem(raw);
+        if (invalid !== undefined)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: invalid,
+                extensions: { fields: [{ field: "playlist", message: invalid }] },
+            });
+        return c.json({ playlist: saveStudioPlaylist(deps.db, raw) });
+    })
+        .post("/settings/pairing", (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        return c.json({ pairing: resetStudioPairing(deps.db) });
+    })
+        .get("/packs/:projectId", zValidator("param", projectParam, onInvalid), (c) => {
+        const result = uploadPack(deps, c.req.valid("param").projectId);
+        if (!result.ok)
+            return unknownProject(c);
+        return c.json(result.pack);
+    })
+        // Prepare upload's AI use tick: the project's uploaded clips are real footage.
+        .put("/packs/:projectId/real-footage", zValidator("param", projectParam, onInvalid), zValidator("json", realFootageBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId } = c.req.valid("param");
+        if (!uploadPack(deps, projectId).ok)
+            return unknownProject(c);
+        saveRealFootage(deps.db, projectId, c.req.valid("json").realFootage);
+        const result = uploadPack(deps, projectId);
+        return result.ok ? c.json(result.pack) : unknownProject(c);
+    })
+        .post("/packs/:projectId/choose", zValidator("param", projectParam, onInvalid), zValidator("json", chooseBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId } = c.req.valid("param");
+        const { short } = c.req.valid("json");
+        const result = uploadPack(deps, projectId);
+        if (!result.ok)
+            return unknownProject(c);
+        if (packItem(result.pack, short) === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: `This project has no short ${String(short)}. Reload the project page and press Prepare upload again.`,
+            });
+        chosen = { projectId, short, at: deps.clock.now().getTime() };
+        return c.json({ chosen: { projectId, short: short ?? null } });
+    })
+        // The extension's routes.
+        .options("/ext/pair", (c) => {
+        allowOrigin(c, true);
+        return c.body(null, 204);
+    })
+        .options("/ext/*", (c) => {
+        allowOrigin(c, false);
+        return c.body(null, 204);
+    })
+        .post("/ext/pair", (c) => {
+        allowOrigin(c, true);
+        const result = pairStudioExtension(deps.db, bearerToken(c.req.header("authorization")), c.req.header("origin"), deps.clock.now());
+        if (!result.ok)
+            return result.reason === "bad-token"
+                ? refused(c)
+                : problem(c, {
+                    status: 403,
+                    title: titleOf(403),
+                    detail: "Only the Slopify Studio browser extension can pair with Slopify. Install it (see Settings → YouTube Studio) and pair from its options page.",
+                });
+        // The origin is paired now; the response carries its headers.
+        allowOrigin(c, false);
+        return c.json({ paired: true, origin: result.pairing.origin });
+    })
+        .get("/ext/pack", (c) => {
+        allowOrigin(c, false);
+        if (!studioRequestAllowed(deps.db, bearerToken(c.req.header("authorization")), c.req.header("origin")))
+            return refused(c);
+        const fresh = chosen !== undefined && deps.clock.now().getTime() - chosen.at <= choiceMs
+            ? chosen
+            : undefined;
+        if (fresh === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "Nothing is chosen to fill in. In Slopify, open the project, press Prepare upload, then Fill in YouTube Studio.",
+            });
+        const result = uploadPack(deps, fresh.projectId);
+        const item = result.ok ? packItem(result.pack, fresh.short) : undefined;
+        if (!result.ok || item === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "The project chosen to fill in is gone. In Slopify, open the project again and press Fill in YouTube Studio.",
+            });
+        return c.json({ pack: result.pack, item });
+    })
+        .get("/ext/files/:projectId/:asset", zValidator("param", fileParam, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!studioRequestAllowed(deps.db, bearerToken(c.req.header("authorization")), c.req.header("origin")))
+            return refused(c);
+        const { projectId, asset } = c.req.valid("param");
+        // Only the thumbnails of a pack: the extension needs nothing else from the disk.
+        const result = uploadPack(deps, projectId);
+        const listed = result.ok &&
+            result.pack.items.some((item) => item.thumbnails.some((thumbnail) => thumbnail.asset === asset));
+        const found = listed ? findDownload(deps, projectId, asset) : undefined;
+        if (found === undefined || !found.ok)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "That thumbnail isn't in the project's upload pack any more. Reload the project in Slopify and press Fill in YouTube Studio again.",
+            });
+        return c.body(Readable.toWeb(createReadStream(found.download.path)), 200, {
+            "content-type": found.download.contentType,
+            "content-length": String(found.download.bytes),
+            "x-content-type-options": "nosniff",
+        });
+    }));
+}
+function unknownProject(c) {
+    return problem(c, {
+        status: 404,
+        title: titleOf(404),
+        detail: "This project no longer exists. Go back to Projects and open it again.",
+    });
+}

package/dist/edge/http/style-preview.js

@@ -0,0 +1,100 @@
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { StylePreviewError } from "../../slices/style-preview/render.js";
+import { stylePreviewRequestSchema } from "../../slices/style-preview/schema.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+// POST renders (or finds) the preview for a set of caption and Look settings and answers where
+// to play it; GET streams the mp4, with byte ranges so the browser's player can seek.
+const fileParam = z.object({ file: z.string().regex(/^[a-f0-9]{64}\.mp4$/) });
+export function stylePreviewRoutes(deps) {
+    return new Hono()
+        .post("/", zValidator("json", stylePreviewRequestSchema, onInvalid), async (c) => {
+        const previews = deps.stylePreviews;
+        if (previews === undefined)
+            return unavailable(c);
+        try {
+            const result = await previews.render(c.req.valid("json"));
+            c.header("Cache-Control", "no-store");
+            return c.json({
+                hash: result.hash,
+                url: `/api/style-preview/${result.hash}.mp4?v=${String(result.version)}`,
+                cached: result.cached,
+                seconds: result.seconds,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof StylePreviewError))
+                throw error;
+            const status = error.reason === "font-missing" ? 409 : error.reason === "ffmpeg-missing" ? 503 : 500;
+            return problem(c, {
+                status,
+                title: titleOf(status),
+                detail: error.message,
+                extensions: { reason: error.reason },
+            });
+        }
+    })
+        .get("/:file", zValidator("param", fileParam, onInvalid), (c) => {
+        const saved = deps.stylePreviews?.file(c.req.valid("param").file.slice(0, 64));
+        if (saved === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This style preview is no longer saved; Slopify keeps only the most recent ones. Press Render again to make it.",
+            });
+        const headers = {
+            "content-type": "video/mp4",
+            "accept-ranges": "bytes",
+            "cache-control": "no-cache",
+            "x-content-type-options": "nosniff",
+        };
+        const range = byteRange(c.req.header("range"), saved.bytes);
+        if (range === "unsatisfiable")
+            return new Response(null, {
+                status: 416,
+                headers: { ...headers, "content-range": `bytes */${String(saved.bytes)}` },
+            });
+        const { start, end } = range ?? { start: 0, end: saved.bytes - 1 };
+        const body = Readable.toWeb(createReadStream(saved.path, { start, end }));
+        return new Response(body, {
+            status: range === undefined ? 200 : 206,
+            headers: {
+                ...headers,
+                "content-length": String(end - start + 1),
+                ...(range === undefined
+                    ? {}
+                    : { "content-range": `bytes ${String(start)}-${String(end)}/${String(saved.bytes)}` }),
+            },
+        });
+    });
+}
+// One `bytes=` range, as browsers ask for media; anything else is answered with the whole file.
+export function byteRange(header, size) {
+    const matched = /^bytes=(\d*)-(\d*)$/.exec(header?.trim() ?? "");
+    if (matched === null)
+        return undefined;
+    const [, from = "", to = ""] = matched;
+    if (from === "" && to === "")
+        return undefined;
+    if (from === "") {
+        const suffix = Number(to);
+        if (suffix === 0)
+            return "unsatisfiable";
+        return { start: Math.max(0, size - suffix), end: size - 1 };
+    }
+    const start = Number(from);
+    const end = to === "" ? size - 1 : Math.min(Number(to), size - 1);
+    if (start >= size || end < start)
+        return "unsatisfiable";
+    return { start, end };
+}
+function unavailable(c) {
+    return problem(c, {
+        status: 503,
+        title: titleOf(503),
+        detail: "The style preview isn't available because this Slopify started without its video renderer. Restart Slopify, then press Render again.",
+    });
+}

package/dist/edge/http/subtitles.js

@@ -16,7 +16,7 @@ function revisionRequired(c) {
     return problem(c, {
         status: 409,
         title: titleOf(409),
-        detail: "This change is now made from the Edit tab. Choose Edit project, save your change, then use Rebuild affected outputs.",
+        detail: "This change is now made from the Edit tab. Choose Edit project, save your change, then use Choose what to remake (in the project's More menu).",
         extensions: { reason: "revision-required" },
     });
 }

package/dist/edge/http/trash.js

@@ -0,0 +1,69 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { withProjectControl } from "../../slices/control/lock.js";
+import { trashKinds } from "../../slices/trash/model.js";
+import { deleteNow, listTrash, restoreItem } from "../../slices/trash/service.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const itemParam = z.object({
+    kind: z.enum(trashKinds),
+    id: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[0-9A-Za-z_-]+$/),
+});
+const status = {
+    "not-found": 404,
+    running: 409,
+    files: 500,
+    "template-in-trash": 409,
+    "template-gone": 409,
+};
+const details = {
+    "not-found": "This item is no longer in the trash: it was restored or removed for good. Reload Settings → Trash to see what is left.",
+    running: "This project is still running. Use Cancel run on the project page first, then try again.",
+    files: "Some of this project's files could not be removed. Close any program using files in the project folder, then press Delete now again.",
+    "template-in-trash": "This schedule's template is in the trash too. Restore the template first (it is listed here), then restore the schedule.",
+    "template-gone": "This schedule's template was removed for good, so the schedule has nothing to run. It cannot be restored; Delete now removes it from the trash.",
+};
+function refused(c, reason, detail) {
+    return problem(c, {
+        status: status[reason],
+        title: titleOf(status[reason]),
+        detail: detail === undefined ? details[reason] : `${details[reason]} (${detail})`,
+        extensions: { reason },
+    });
+}
+// Settings → Trash: the list, Restore and Delete now. The daily purge runs from main.ts.
+export function trashRoutes(deps) {
+    const trash = {
+        db: deps.db,
+        paths: deps.paths,
+        clock: deps.clock,
+        log: deps.log,
+        hasInflight: deps.runner.hasInflight,
+    };
+    return new Hono()
+        .get("/", (c) => c.json({ items: listTrash(trash) }))
+        .post("/:kind/:id/restore", zValidator("param", itemParam, onInvalid), (c) => {
+        const { kind, id } = c.req.valid("param");
+        const result = restoreItem(trash, kind, id);
+        if (!result.ok)
+            return refused(c, result.reason);
+        // A restored project picks up where it was: unfinished work goes on, a queued batch
+        // item is back in its place.
+        if (kind === "project")
+            deps.runner.tick(id);
+        return c.json({ restored: result.value });
+    })
+        .delete("/:kind/:id", zValidator("param", itemParam, onInvalid), async (c) => {
+        const { kind, id } = c.req.valid("param");
+        const result = kind === "project"
+            ? await withProjectControl(deps.db, id, () => deleteNow(trash, kind, id))
+            : deleteNow(trash, kind, id);
+        if (!result.ok)
+            return refused(c, result.reason, result.detail);
+        return c.body(null, 204);
+    });
+}

package/dist/edge/http/update.js

@@ -10,7 +10,7 @@ export function updateRoutes(deps) {
         status: "idle",
         blockedReason: "This copy of Slopify cannot update itself from the app. Update it the way you installed it, for example by running the launcher again.",
     };
-    return new Hono()
+    return (new Hono()
         .get("/ready", (c) => {
         c.header("Cache-Control", "no-store");
         if (!deps.updater?.ready(c.req.header("X-Slopify-Update-Token") ?? ""))
@@ -31,6 +31,23 @@ export function updateRoutes(deps) {
         return c.json(deps.updater === undefined
             ? unavailable
             : await deps.updater.check(c.req.query("refresh") === "1"));
+    })
+        // Drops an update that is waiting for running work to finish.
+        .delete("/", async (c) => {
+        const origin = c.req.header("Origin");
+        if (origin !== undefined && origin !== new URL(c.req.url).origin)
+            return problem(c, {
+                status: 403,
+                title: titleOf(403),
+                detail: "For your safety, updates can only be changed from the Slopify page itself. Open Slopify and try again there.",
+            });
+        if (deps.updater?.cancelWaiting() !== true)
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "No update is waiting to install. Reload the page to see the current update status.",
+            });
+        return c.json(await deps.updater.check());
     })
         .post("/", async (c) => {
         const origin = c.req.header("Origin");
@@ -41,7 +58,11 @@ export function updateRoutes(deps) {
                 detail: "For your safety, updates can only be started from the Slopify page itself. Open Slopify and try again there.",
             });
         if (deps.updater === undefined)
-            return problem(c, { status: 409, title: titleOf(409), detail: unavailable.blockedReason });
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: unavailable.blockedReason,
+            });
         const result = await deps.updater.start();
         if (result.ok)
             return c.json(result.info, 202);
@@ -53,5 +74,5 @@ export function updateRoutes(deps) {
                 result.info.error ??
                 "You already have the latest version of Slopify.",
         });
-    });
+    }));
 }

package/dist/edge/http/whats-new.js

@@ -0,0 +1,15 @@
+import { Hono } from "hono";
+import { markPatchNotesSeen } from "../../slices/patch-notes/seen.js";
+import { dismissWhatsNew, readWhatsNew } from "../../slices/settings/whats-new.js";
+// Preserve Hono's inferred route types for the web client.
+export function whatsNewRoutes(deps) {
+    return (new Hono()
+        .get("/", (c) => c.json(readWhatsNew(deps.db, deps.version)))
+        // The tour stands in for the patch notes on a major update (its last step links to
+        // them), so closing it also closes this version's notes: never two popups in a row.
+        .post("/seen", (c) => {
+        const view = dismissWhatsNew(deps.db, deps.version);
+        markPatchNotesSeen(deps.db, deps.version);
+        return c.json(view);
+    }));
+}

package/dist/edge/http/youtube-edits.js

@@ -0,0 +1,83 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { projectExists } from "../../slices/admission/repo.js";
+import { descriptionFields, withEdit, withoutEdit } from "../../slices/youtube/edits.js";
+import { readDescriptionEdits, writeDescriptionEdits } from "../../slices/youtube/edits-repo.js";
+import { descriptionMaxCharacters } from "../../slices/youtube/model.js";
+import { channelLinksProblem } from "../../slices/youtube/placeholders.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+import { channelLinksBody } from "./settings.js";
+const idParam = z.object({ id: z.string().min(1).max(64) });
+const fieldParam = idParam.extend({ field: z.enum(descriptionFields) });
+// A field is at most a description long; the bound keeps a pasted novel off the table, and
+// YouTube's own limit is shown beside the field rather than refused here.
+const fieldBody = z.object({
+    text: z.string().max(descriptionMaxCharacters * 4),
+    base: z.string().max(descriptionMaxCharacters * 4),
+});
+const gone = "This project no longer exists. Go back to Projects to pick another.";
+// The project page's hand edits to the YouTube description (`slices/youtube/edits.ts`). The
+// server keeps them; the page applies the merge rules to the text it shows.
+export function youtubeEditRoutes(deps) {
+    const exists = (id) => projectExists(deps.db, id);
+    const missing = (c) => problem(c, { status: 404, title: titleOf(404), detail: gone });
+    const now = () => deps.clock.now().toISOString();
+    return (new Hono()
+        .get("/:id/youtube-edits", zValidator("param", idParam, onInvalid), (c) => {
+        const { id } = c.req.valid("param");
+        return exists(id) ? c.json(readDescriptionEdits(deps.db, id)) : missing(c);
+    })
+        // Saves the user's text for one field with the generated text it was edited from; text
+        // equal to that generated text clears the edit. "Keep mine" is this call with the new
+        // generated text as the base.
+        .put("/:id/youtube-edits/fields/:field", zValidator("param", fieldParam, onInvalid), zValidator("json", fieldBody, onInvalid), (c) => {
+        const { id, field } = c.req.valid("param");
+        if (!exists(id))
+            return missing(c);
+        const { text, base } = c.req.valid("json");
+        const saved = transact(deps.db, () => {
+            const current = readDescriptionEdits(deps.db, id);
+            const next = { ...current, fields: withEdit(current.fields, field, text, base) };
+            writeDescriptionEdits(deps.db, id, next, now());
+            return next;
+        });
+        return c.json(saved);
+    })
+        // "Use it": the field follows the generated text again.
+        .delete("/:id/youtube-edits/fields/:field", zValidator("param", fieldParam, onInvalid), (c) => {
+        const { id, field } = c.req.valid("param");
+        if (!exists(id))
+            return missing(c);
+        const saved = transact(deps.db, () => {
+            const current = readDescriptionEdits(deps.db, id);
+            const next = { ...current, fields: withoutEdit(current.fields, field) };
+            writeDescriptionEdits(deps.db, id, next, now());
+            return next;
+        });
+        return c.json(saved);
+    })
+        // The project's own links, such as its "Previous video"; they win over Settings' list.
+        .put("/:id/youtube-edits/links", zValidator("param", idParam, onInvalid), zValidator("json", channelLinksBody, onInvalid), (c) => {
+        const { id } = c.req.valid("param");
+        if (!exists(id))
+            return missing(c);
+        const links = c.req
+            .valid("json")
+            .links.map((link) => ({ name: link.name.trim(), url: link.url.trim() }));
+        const refused = channelLinksProblem(links);
+        if (refused !== undefined)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: `This project's links weren't saved: ${refused} Then press Save links under YouTube on the Video section.`,
+            });
+        const saved = transact(deps.db, () => {
+            const next = { ...readDescriptionEdits(deps.db, id), links };
+            writeDescriptionEdits(deps.db, id, next, now());
+            return next;
+        });
+        return c.json(saved);
+    }));
+}

package/dist/edge/native-update.js

@@ -0,0 +1,62 @@
+import { setTimeout as delay } from "node:timers/promises";
+/**
+ * `slopify update` for a native install: asks the running app to update itself, exactly as the
+ * Update button in Settings does (wait for running work, install, back up the database, start the
+ * new version, roll back if it doesn't come up), and follows it until it has finished.
+ */
+export async function runNativeUpdate(deps) {
+    const poll = deps.pollMs ?? 2000;
+    const read = async (refresh = false) => {
+        const response = await deps.fetch(`${deps.origin}/api/update${refresh ? "?refresh=1" : ""}`);
+        if (!response.ok)
+            throw new Error(`Slopify answered ${response.status}.`);
+        return (await response.json());
+    };
+    let info;
+    try {
+        info = await read(true);
+    }
+    catch {
+        throw new Error(`Slopify isn't running at ${deps.origin}, so there is nothing to update. Start it (npx @gentbajko/slopify) and run slopify update again; if it runs on another port, add --port <number>. To just start the newest version, run npx @gentbajko/slopify@latest.`);
+    }
+    if (info.status === "error" && info.error !== undefined && info.latestVersion === null)
+        throw new Error(info.error);
+    if (!info.available) {
+        deps.report(`Slopify ${info.currentVersion} is already the newest version.`);
+        return;
+    }
+    const target = info.latestVersion;
+    let told = false;
+    while (info.busy) {
+        if (!told)
+            deps.report("Slopify is generating right now. Waiting for running work to finish before updating (press Ctrl+C to cancel; nothing has been changed yet)...");
+        told = true;
+        await delay(poll);
+        info = await read();
+    }
+    if (!info.canUpdate)
+        throw new Error(info.blockedReason ??
+            info.error ??
+            "Slopify can't update right now. Open Settings in Slopify to see why.");
+    const started = await deps.fetch(`${deps.origin}/api/update`, { method: "POST" });
+    if (!started.ok) {
+        const body = (await started.json().catch(() => ({})));
+        throw new Error(body.detail ?? `Slopify refused to start the update (${started.status}).`);
+    }
+    deps.report(`Updating Slopify ${info.currentVersion} to ${target}...`);
+    const deadline = Date.now() + (deps.restartMs ?? 10 * 60_000);
+    while (Date.now() < deadline) {
+        await delay(poll);
+        const now = await read().catch(() => undefined);
+        if (now === undefined || now.status === "installing" || now.status === "restarting")
+            continue;
+        if (now.currentVersion === target && now.status !== "error") {
+            deps.report(`Slopify ${target} is running at ${deps.origin}`);
+            return;
+        }
+        if (now.status === "error" || now.error !== undefined)
+            throw new Error(now.error ??
+                "The update did not finish, so Slopify kept or put back the previous version. The reason is in logs/updates.log inside your Slopify data folder.");
+    }
+    throw new Error(`Slopify didn't answer at ${deps.origin} within 10 minutes after the update started. Check it in the browser; the updater puts the previous version back on its own if the new one doesn't start, and the reason is in logs/updates.log inside your Slopify data folder.`);
+}