@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/edge/http/studio.js

@@ -0,0 +1,287 @@
+import { createReadStream, statSync } from "node:fs";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { projectById } from "../../slices/admission/repo.js";
+import { channelById } from "../../slices/channels/repo.js";
+import { findDownload } from "../../slices/storage/downloads.js";
+import { studioPlaylistMax } from "../../slices/studio/model.js";
+import { packItem, uploadPack } from "../../slices/studio/pack.js";
+import { enqueueFill, readFillQueue, removeFill, } from "../../slices/studio/queue.js";
+import { bearerToken, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, 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 queueItemBody = z.object({
+    projectId: id,
+    short: z.number().int().min(1).max(99).nullable().optional(),
+});
+const playlistBody = z.object({
+    playlist: z.string().max(studioPlaylistMax * 2),
+    // A channel's own playlist; absent is the default every other channel uses.
+    channelId: id.optional(),
+});
+const realFootageBody = z.object({ realFootage: z.boolean() });
+// The extension builds the app ships (`scripts/copy-extension.mjs`), by browser.
+const extensionFiles = {
+    "chrome.zip": "slopify-studio-chrome.zip",
+    "firefox.zip": "slopify-studio-firefox.zip",
+};
+const extensionParam = z.object({ file: z.enum(["chrome.zip", "firefox.zip"]) });
+// 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 waits to be filled, with each project's title; entries whose project is gone are left
+    // out (the extension drops them when it reaches them).
+    const queueView = (entries) => entries.flatMap((entry) => {
+        const project = projectById(deps.db, entry.projectId);
+        return project === undefined ? [] : [{ ...entry, projectTitle: project.title }];
+    });
+    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),
+            channelPlaylists: readChannelPlaylists(deps.db),
+            pairing: studioPairing(deps.db),
+        });
+    })
+        .put("/settings/playlist", zValidator("json", playlistBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { playlist: raw, channelId } = c.req.valid("json");
+        if (channelId !== undefined && channelById(deps.db, channelId) === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "The playlist wasn't saved: that channel no longer exists. Reload Settings → YouTube Studio and pick the channel again.",
+            });
+        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, channelId),
+            channelId: channelId ?? null,
+        });
+    })
+        .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.`,
+            });
+        const queue = enqueueFill(deps.db, projectId, short ?? null, deps.clock.now());
+        return c.json({ chosen: { projectId, short: short ?? null }, queue: queueView(queue) });
+    })
+        // What waits for the extension, oldest first: each new upload dialog takes the first.
+        .get("/queue", (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        return c.json({ queue: queueView(readFillQueue(deps.db, deps.clock.now())) });
+    })
+        .post("/queue/remove", zValidator("json", queueItemBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, short } = c.req.valid("json");
+        return c.json({
+            queue: queueView(removeFill(deps.db, projectId, short ?? null, deps.clock.now())),
+        });
+    })
+        // The extension's own zips, for Settings' and Prepare upload's Download.
+        .get("/extension/:file", zValidator("param", extensionParam, onInvalid), (c) => {
+        const { file } = c.req.valid("param");
+        const name = extensionFiles[file] ?? "";
+        const path = deps.extensionDist === undefined ? undefined : join(deps.extensionDist, name);
+        const stat = path === undefined ? undefined : statSync(path, { throwIfNoEntry: false });
+        if (path === undefined || stat === undefined || !stat.isFile())
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "The Slopify Studio extension isn't included in this copy of Slopify, so there is nothing to download. Update or reinstall Slopify; when running from the repository, run `npm run build` at its root, which builds the extension too.",
+            });
+        return c.body(Readable.toWeb(createReadStream(path)), 200, {
+            "content-type": "application/zip",
+            "content-length": String(stat.size),
+            "content-disposition": `attachment; filename="${name}"`,
+            "x-content-type-options": "nosniff",
+        });
+    })
+        // 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);
+        // The first waiting item that can still be filled; one whose project or short is gone
+        // leaves the queue.
+        const now = deps.clock.now();
+        let gone = 0;
+        for (const entry of readFillQueue(deps.db, now)) {
+            const result = uploadPack(deps, entry.projectId);
+            const item = result.ok ? packItem(result.pack, entry.short ?? undefined) : undefined;
+            if (result.ok && item !== undefined) {
+                const waiting = readFillQueue(deps.db, now).length;
+                return c.json({ pack: result.pack, item, waiting });
+            }
+            removeFill(deps.db, entry.projectId, entry.short, now);
+            gone += 1;
+        }
+        return problem(c, {
+            status: 404,
+            title: titleOf(404),
+            detail: gone > 0
+                ? "The project chosen to fill in is gone. In Slopify, open the project again, press Prepare upload, then Fill in YouTube Studio."
+                : "Nothing is waiting to be filled in. In Slopify, open the project, press Prepare upload, then Fill in YouTube Studio.",
+        });
+    })
+        // The extension filled an item: it leaves the queue, so the next upload dialog takes the
+        // next one.
+        .post("/ext/filled", zValidator("json", queueItemBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!studioRequestAllowed(deps.db, bearerToken(c.req.header("authorization")), c.req.header("origin")))
+            return refused(c);
+        const { projectId, short } = c.req.valid("json");
+        const left = removeFill(deps.db, projectId, short ?? null, deps.clock.now());
+        return c.json({ waiting: left.length });
+    })
+        .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,61 @@
+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 { fileResponse } from "./byte-range.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+export { byteRange } from "./byte-range.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.",
+            });
+        return fileResponse(c, saved.path, saved.bytes, {
+            "content-type": "video/mp4",
+            "cache-control": "no-cache",
+            "x-content-type-options": "nosniff",
+        });
+    });
+}
+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/tutorials.js

@@ -0,0 +1,59 @@
+import { Hono } from "hono";
+import { tutorialPageIdPattern } from "../../slices/tutorials/anchors.js";
+import { bundledTutorialsDir, loadTutorials, searchTutorials, TutorialsMissing, } from "../../slices/tutorials/library.js";
+import { problem, titleOf } from "./problem.js";
+// A build without its tutorials says so in plain words; anything else is the app's error handler's.
+function missing(c, error) {
+    if (!(error instanceof TutorialsMissing))
+        throw error;
+    return problem(c, { status: 500, title: titleOf(500), detail: error.message });
+}
+// Help → Tutorials: the sidebar and page list, a search across every page, and one page's
+// Markdown. The pages ship with the app, so they are read once and kept.
+// Preserve Hono's inferred route types for the web client.
+export function tutorialPagesRoutes(deps) {
+    const dir = deps.tutorialsDir ?? bundledTutorialsDir();
+    let book;
+    const read = () => {
+        book ??= loadTutorials(dir).catch((error) => {
+            book = undefined;
+            throw error;
+        });
+        return book;
+    };
+    return new Hono()
+        .get("/", async (c) => {
+        try {
+            return c.json((await read()).index);
+        }
+        catch (error) {
+            return missing(c, error);
+        }
+    })
+        .get("/search", async (c) => {
+        const query = (c.req.query("q") ?? "").slice(0, 200);
+        try {
+            return c.json({ hits: searchTutorials(await read(), query) });
+        }
+        catch (error) {
+            return missing(c, error);
+        }
+    })
+        .get("/:page", async (c) => {
+        const id = c.req.param("page");
+        let markdown;
+        try {
+            markdown = tutorialPageIdPattern.test(id) ? (await read()).pages.get(id) : undefined;
+        }
+        catch (error) {
+            return missing(c, error);
+        }
+        if (markdown === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: `There is no tutorial called ${id} in this version of Slopify. Pick one from the list on Help → Tutorials, or search there.`,
+            });
+        return c.body(markdown, 200, { "content-type": "text/markdown; charset=utf-8" });
+    });
+}

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,92 @@
+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 { projectChannelId } from "../../slices/channels/repo.js";
+import { descriptionFields, withEdit, withoutEdit } from "../../slices/youtube/edits.js";
+import { readChannelLinksFor, 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);
+    })
+        // The links of the project's channel, which its placeholders fill from after its own.
+        .get("/:id/channel-links", zValidator("param", idParam, onInvalid), (c) => {
+        const { id } = c.req.valid("param");
+        if (!exists(id))
+            return missing(c);
+        const channelId = projectChannelId(deps.db, id);
+        return c.json({ channelId, links: readChannelLinksFor(deps.db, channelId) });
+    })
+        // 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 its channel's 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);
+    }));
+}