@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/edge/http/schedules.js

@@ -2,18 +2,26 @@ import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { z } from "zod";
+import { setupSectionNames } from "../../slices/project-templates/setup-sections.js";
 import { calendarRange } from "../../slices/schedules/agenda.js";
 import { rejectHeldTopics, restoreRejectedTopics } from "../../slices/schedules/held-bulk.js";
 import { preparedTopics, prepareTopic } from "../../slices/schedules/prepare.js";
-import { calendarMaxDays, calendarSchema, heldTopicEditSchema, heldTopicSchema, queueMax, scheduleCreateSchema, scheduleRunSchema, scheduleSummarySchema, scheduleUpdateSchema, topicMoveSchema, topicQueueSchema, topicTransferSchema, } from "../../slices/schedules/schema.js";
+import { rescoreTopics } from "../../slices/schedules/rescore.js";
+import { calendarMaxDays, calendarSchema, heldTopicEditSchema, heldTopicSchema, queueMax, scheduleCreateSchema, scheduleRunSchema, scheduleSaveBodySchema, scheduleSummarySchema, scheduleVersionBodySchema, topicMoveSchema, topicQueueSchema, topicTransferSchema, } from "../../slices/schedules/schema.js";
 import { cancelSchedule, createSchedule, deleteSchedule, listScheduleRuns, listSchedules, pauseSchedule, resumeSchedule, updateSchedule, } from "../../slices/schedules/service.js";
+import { scoresFor } from "../../slices/schedules/topic-scores.js";
 import { approveHeldTopics, editHeldTopic, heldTopics, moveTopic, rejectHeldTopic, replaceTopics, transferTopic, } from "../../slices/schedules/topics.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
+import { onInvalid, problem } from "./problem.js";
+import { refusal } from "./refusal.js";
 const id = z.object({ id: z.uuid() });
 const topicParam = z.object({ id: z.uuid(), topicId: z.string().min(1).max(100) });
 const topicIds = z.array(z.string().min(1).max(100)).min(1).max(queueMax);
-const heldIds = z.object({ ids: topicIds }).strict();
-const heldRestore = z
+// Prepare one queued topic: its title as the queue lists it.
+export const prepareTopicBody = z.object({ topic: z.string().min(1).max(500) }).strict();
+// Approve one held topic, optionally under another title.
+export const approveHeldTopicBody = z.object({ title: z.string().optional() }).strict();
+export const heldIds = z.object({ ids: topicIds }).strict();
+export const heldRestore = z
     .object({
     topics: z
         .array(z
@@ -27,38 +35,36 @@ const heldRestore = z
 })
     .strict();
 function refused(c, result) {
-    const status = ["not-found", "missing-template", "topic-not-found"].includes(result.reason)
-        ? 404
-        : [
-            "conflict",
-            "cancel-required",
-            "spend-limit",
-            "unsupported-media",
-            "queue-full",
-            "busy",
-        ].includes(result.reason)
-            ? 409
-            : 400;
     const detail = {
         "invalid-input": "Some schedule settings are not valid. Check each field and save again.",
         "not-found": "This schedule no longer exists; it may have been deleted. Reload the page to see your schedules.",
         conflict: "This schedule changed while you were editing, possibly because a run just started. Reload the page to see the latest, then make your change again.",
         "cancel-required": "This schedule is still active. Cancel it first, then delete it. Completed schedules can be deleted straight away.",
         "missing-template": "The template you picked was deleted or changed. Choose a template again, then save.",
-        "unsupported-media": "This template uses audio, images, a thumbnail, shorts background music or an ambient sound file you supplied, so it cannot run on a schedule: a scheduled run has no one to attach the file again. Pick a template that generates these instead, or on Play remove the music under Outputs → More shorts options (or pick Rain, Fireplace or Wind under Video and style → Ambient sound) and save the template again.",
+        "unsupported-media": `This template uses audio, images, a thumbnail, shorts background music or an ambient sound file you supplied, so it cannot run on a schedule: a scheduled run has no one to attach the file again. Pick a template that generates these instead, or open this one in Edit template, remove the music under ${setupSectionNames.shorts} (or pick Rain, Fireplace or Wind as the Ambient sound under ${setupSectionNames.video}) and save it again.`,
         "not-due": "This one-off time has already passed. Choose a time in the future.",
         "spend-limit": "The estimated cost is above this schedule's spend limit, or some prices are unknown. Raise the spend limit or choose models with known prices.",
-        readiness: "A provider this template needs is not ready, for example a missing API key, model or voice. Check Settings → Providers, then try again.",
+        readiness: "A provider this template needs is not ready, for example a missing API key, model or voice. Check Settings → Keys & services, then try again.",
         "queue-full": `A schedule's topic queue holds at most ${String(queueMax)} topics. Remove some under Schedules → Edit, then try again.`,
         "topic-not-found": "This topic was already approved, turned down or used. Reload the page to see the topics waiting now.",
         busy: "Slopify is already generating topics for this schedule. Wait for it to finish, then try again.",
+        "not-ready": "This schedule's template has no version approved for schedules. Open it from Templates with Edit template, then choose More → Approve for schedules.",
         "invalid-topics": "Some topics name keywords this template does not use. Check each topic under Schedules → Edit and save again.",
     };
-    return problem(c, {
-        status,
-        title: titleOf(status),
+    return refusal(c, result.reason, {
+        statuses: {
+            "not-found": 404,
+            "missing-template": 404,
+            "topic-not-found": 404,
+            conflict: 409,
+            "cancel-required": 409,
+            "spend-limit": 409,
+            "unsupported-media": 409,
+            "queue-full": 409,
+            busy: 409,
+        },
+        otherwise: 400,
         detail: result.message ?? detail[result.reason],
-        extensions: { reason: result.reason },
     });
 }
 export function scheduleRoutes(deps) {
@@ -90,38 +96,44 @@ function routes(deps) {
             ? c.json({
                 schedule: scheduleSummarySchema.parse(schedule),
                 runs: runs.value.map((run) => scheduleRunSchema.parse(run)),
+                // Each queued and held topic's score and reasons, by `topicKey`, while ranking
+                // is on.
+                scores: scoresFor(service().db, schedule.id, [
+                    ...schedule.items.map((item) => item.title),
+                    ...heldTopics(service(), schedule.id).map((topic) => topic.title),
+                ]),
             })
             : refused(c, runs);
     })
-        .put("/:id", zValidator("param", id, onInvalid), zValidator("json", scheduleUpdateSchema.unwrap().omit({ id: true }), onInvalid), (c) => {
+        .put("/:id", zValidator("param", id, onInvalid), zValidator("json", scheduleSaveBodySchema, onInvalid), (c) => {
         const result = updateSchedule(service(), {
             ...c.req.valid("json"),
             id: c.req.valid("param").id,
         });
         return result.ok ? c.json(scheduleSummarySchema.parse(result.value)) : refused(c, result);
     })
-        .post("/:id/pause", zValidator("param", id, onInvalid), zValidator("json", z.object({ baseVersion: z.number().int().positive() }).strict(), onInvalid), (c) => {
+        .post("/:id/pause", zValidator("param", id, onInvalid), zValidator("json", scheduleVersionBodySchema, onInvalid), (c) => {
         const result = pauseSchedule(service(), {
             ...c.req.valid("json"),
             id: c.req.valid("param").id,
         });
         return result.ok ? c.json(scheduleSummarySchema.parse(result.value)) : refused(c, result);
     })
-        .post("/:id/resume", zValidator("param", id, onInvalid), zValidator("json", z.object({ baseVersion: z.number().int().positive() }).strict(), onInvalid), (c) => {
+        .post("/:id/resume", zValidator("param", id, onInvalid), zValidator("json", scheduleVersionBodySchema, onInvalid), (c) => {
         const result = resumeSchedule(service(), {
             ...c.req.valid("json"),
             id: c.req.valid("param").id,
         });
         return result.ok ? c.json(scheduleSummarySchema.parse(result.value)) : refused(c, result);
     })
-        .post("/:id/cancel", zValidator("param", id, onInvalid), zValidator("json", z.object({ baseVersion: z.number().int().positive() }).strict(), onInvalid), (c) => {
+        .post("/:id/cancel", zValidator("param", id, onInvalid), zValidator("json", scheduleVersionBodySchema, onInvalid), (c) => {
         const result = cancelSchedule(service(), {
             ...c.req.valid("json"),
             id: c.req.valid("param").id,
         });
         return result.ok ? c.json(scheduleSummarySchema.parse(result.value)) : refused(c, result);
     })
-        .delete("/:id", zValidator("param", id, onInvalid), zValidator("json", z.object({ baseVersion: z.number().int().positive() }).strict(), onInvalid), (c) => {
+        .delete("/:id", zValidator("param", id, onInvalid), zValidator("json", scheduleVersionBodySchema, onInvalid), (c) => {
         const result = deleteSchedule(service(), {
             ...c.req.valid("json"),
             id: c.req.valid("param").id,
@@ -132,14 +144,31 @@ function routes(deps) {
         const scheduleId = c.req.valid("param").id;
         if (listSchedules(service()).every((item) => item.id !== scheduleId))
             return refused(c, { ok: false, reason: "not-found" });
+        const topics = heldTopics(service(), scheduleId).map((topic) => heldTopicSchema.parse(topic));
         return c.json({
-            topics: heldTopics(service(), scheduleId).map((topic) => heldTopicSchema.parse(topic)),
+            topics,
+            scores: scoresFor(service().db, scheduleId, topics.map((topic) => topic.title)),
         });
+    })
+        // Rescore: every queued and held topic scored again, then put in score order. With search
+        // ranking it asks Google, DuckDuckGo and Wikipedia, up to 15 seconds.
+        .post("/:id/topics/score", zValidator("param", id, onInvalid), async (c) => {
+        const result = await rescoreTopics(service(), c.req.valid("param").id);
+        if (result.ok)
+            return c.json(scheduleSummarySchema.parse(result.value));
+        if (result.reason === "scoring-off")
+            return problem(c, {
+                status: 409,
+                detail: result.message,
+                extensions: { reason: result.reason },
+            });
+        return refused(c, result);
     })
         // Which queued topics are prepared ahead, and their projects.
         .get("/:id/prepared", zValidator("param", id, onInvalid), (c) => c.json({ prepared: preparedTopics(service(), c.req.valid("param").id) }))
-        // Prepare one queued topic now: everything but the video, which its scheduled day renders.
-        .post("/:id/topics/prepare", zValidator("param", id, onInvalid), zValidator("json", z.object({ topic: z.string().min(1).max(500) }).strict(), onInvalid), async (c) => {
+        // Make ahead one queued topic: everything but the video now, which its scheduled day puts
+        // together.
+        .post("/:id/topics/prepare", zValidator("param", id, onInvalid), zValidator("json", prepareTopicBody, onInvalid), async (c) => {
         const result = await prepareTopic(service(), {
             scheduleId: c.req.valid("param").id,
             title: c.req.valid("json").topic,
@@ -148,17 +177,19 @@ function routes(deps) {
             return c.json({ projectId: result.projectId, title: result.title }, 201);
         const detail = {
             "not-found": "This topic is no longer in the schedule's queue. Reload the page to see the queue as it is now.",
-            "already-prepared": "This topic is already prepared: its project is in Projects under the same title.",
-            "missing-template": "This schedule's template was deleted, so there is nothing to prepare from. Choose another template under Edit.",
-            "spend-limit": "Preparing it would go over this schedule's spend limit. Raise the limit under Edit, or prepare it from Play instead.",
+            "already-prepared": "This topic is already made ahead: its project is in Projects under the same title.",
+            paused: "Its schedule is paused, so it makes nothing, ahead or on its day. Resume it under Calendar → Schedules, then press Make ahead again.",
+            "missing-template": "This schedule's template was deleted, so there is nothing to make it from. Choose another template under Edit.",
+            "spend-limit": "Making it ahead would go over this schedule's spend limit. Raise the limit under Edit, or make it from Create instead.",
+            design: "A poster schedule makes each poster on its day, so there is nothing to make ahead. To have one now, open its poster template (Templates → Poster templates) and press Make a poster; to have it sooner on a schedule, give its row an earlier date in the Schedule section.",
         };
         return problem(c, {
             status: result.reason === "not-found" ? 404 : 409,
-            title: titleOf(result.reason === "not-found" ? 404 : 409),
-            detail: detail[result.reason] ??
+            detail: (result.reason === "not-ready" ? result.detail : undefined) ??
+                detail[result.reason] ??
                 (result.detail === undefined
-                    ? `This topic couldn't be prepared (${result.reason}). Open Play with the schedule's template to see what the setup needs, then try again.`
-                    : `This topic couldn't be prepared: ${result.detail} Fix it in the schedule's template (Library → Templates), then try again.`),
+                    ? `This topic couldn't be made ahead (${result.reason}). Open Create with the schedule's template to see what the setup needs, then try again.`
+                    : `This topic couldn't be made ahead: ${result.detail} Fix it in the schedule's template (Templates → Edit template), then try again.`),
             extensions: { reason: result.reason },
         });
     })
@@ -181,7 +212,6 @@ function routes(deps) {
         if (refusal !== undefined)
             return problem(c, {
                 status: 409,
-                title: titleOf(409),
                 detail: refusal,
                 extensions: { reason: "busy" },
             });
@@ -206,7 +236,7 @@ function routes(deps) {
         const result = restoreRejectedTopics(service(), c.req.valid("param").id, c.req.valid("json").topics);
         return result.ok ? c.json(scheduleSummarySchema.parse(result.value)) : refused(c, result);
     })
-        .post("/:id/topics/held/:topicId/approve", zValidator("param", topicParam, onInvalid), zValidator("json", z.object({ title: z.string().optional() }).strict(), onInvalid), (c) => {
+        .post("/:id/topics/held/:topicId/approve", zValidator("param", topicParam, onInvalid), zValidator("json", approveHeldTopicBody, onInvalid), (c) => {
         const { id: scheduleId, topicId } = c.req.valid("param");
         const { title } = c.req.valid("json");
         const result = approveHeldTopics(service(), scheduleId, [topicId], title === undefined ? {} : { [topicId]: title });
@@ -257,7 +287,6 @@ export function calendarRoutes(deps) {
         if (!result.ok)
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: `Choose a range whose end is after its start and at most ${String(calendarMaxDays)} days long.`,
                 extensions: { reason: result.reason },
             });

package/dist/edge/http/settings.js

@@ -10,9 +10,10 @@ import { readNotificationUrl, saveNotificationUrl } from "../../slices/notificat
 import { appearances, providerIds } from "../../slices/settings/model.js";
 import { readSettings, saveSettings } from "../../slices/settings/playback.js";
 import { addVoice, removeVoice, setVoiceImitatesRealPerson, setVoiceLanguages, voiceIdMax, voiceNameMax, voices, } from "../../slices/settings/voices.js";
+import { clipEncodeSpeeds, noNvenc, renderPriorities, videoEncoders, } from "../../slices/video/encoding.js";
 import { readChannelLinks, writeChannelLinks } from "../../slices/youtube/edits-repo.js";
 import { channelLinkNameMax, channelLinksMax, channelLinksProblem, channelLinkUrlMax, } from "../../slices/youtube/placeholders.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
+import { onInvalid, problem } from "./problem.js";
 const idParam = z.object({ id: z.string().min(1).max(64) });
 // Shape only. The rules - trimming, emptiness, length, the provider speaking at all -
 // are the slice's, so one set of messages reaches the form.
@@ -26,7 +27,7 @@ const voiceLanguagesBody = z.object({ languages: z.array(z.string().max(20)).max
 const voiceRealPersonBody = z.object({ imitatesRealPerson: z.boolean() });
 // Length and scheme are the slice's rules, so their sentences reach the field; this bound only
 // keeps a pasted novel off the parser.
-const notificationBody = z.object({ url: z.string().max(notificationUrlMax * 2) });
+export const notificationBody = z.object({ url: z.string().max(notificationUrlMax * 2) });
 // Shape and a generous bound only; `channelLinksProblem` says what is wrong in Settings' words.
 export const channelLinksBody = z.object({
     links: z
@@ -45,6 +46,10 @@ const playbackBody = z.object({
         .optional(),
     // Absent keeps what is saved, as with loudness.
     subtitleModel: z.enum(englishSubtitleModels).optional(),
+    // Absent keeps what is saved, as with loudness.
+    videoEncoder: z.enum(videoEncoders).optional(),
+    clipEncodeSpeed: z.enum(clipEncodeSpeeds).optional(),
+    renderPriority: z.enum(renderPriorities).optional(),
 });
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
@@ -61,16 +66,34 @@ export function settingsRoutes(deps) {
             ...body,
             loudness: body.loudness ?? saved.loudness,
             subtitleModel: body.subtitleModel ?? saved.subtitleModel,
+            videoEncoder: body.videoEncoder ?? saved.videoEncoder,
+            clipEncodeSpeed: body.clipEncodeSpeed ?? saved.clipEncodeSpeed,
+            renderPriority: body.renderPriority ?? saved.renderPriority,
         });
         if (!result.ok) {
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: "These settings cannot be saved yet. Fix the highlighted fields and try again.",
                 extensions: { fields: result.fields },
             });
         }
         return c.json(result.settings);
+    })
+        // Settings → Production defaults → Video encoder offers the NVIDIA card only where its
+        // encoder works; the first ask runs a test encode, later ones answer from memory.
+        .get("/encoders", async (c) => {
+        const status = deps.nvenc === undefined
+            ? { available: false, reason: noNvenc }
+            : await deps.nvenc();
+        return c.json({
+            nvidia: status.available
+                ? { available: true }
+                : {
+                    available: false,
+                    reason: status.reason,
+                    ...(status.detail === undefined ? {} : { detail: status.detail }),
+                },
+        });
     })
         // The named links `{{Name}}` placeholders in YouTube descriptions fill from
         // (`slices/youtube/placeholders.ts`).
@@ -81,8 +104,7 @@ export function settingsRoutes(deps) {
         if (refused !== undefined)
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
-                detail: `The channel links weren't saved: ${refused} Then press Save in Settings → Channel links.`,
+                detail: `The channel links weren't saved: ${refused} Then press Save in Settings → YouTube Studio and posting.`,
             });
         writeChannelLinks(deps.db, links);
         return c.json({ links: readChannelLinks(deps.db) });
@@ -93,7 +115,6 @@ export function settingsRoutes(deps) {
         if (!result.ok) {
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: `The Notification URL wasn't saved: ${result.message} Fix it in Settings → Notifications → Notification URL, then press Save.`,
                 extensions: { fields: [{ field: "url", message: result.message }] },
             });
@@ -108,7 +129,6 @@ export function settingsRoutes(deps) {
         if (invalid !== undefined) {
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: `The test notification wasn't sent: ${invalid}`,
                 extensions: { fields: [{ field: "url", message: invalid }] },
             });
@@ -118,7 +138,6 @@ export function settingsRoutes(deps) {
             deps.log.write("warn", "notification.test", { detail: sendFailureText(result) });
             return problem(c, {
                 status: 502,
-                title: titleOf(502),
                 detail: `The test notification wasn't delivered: ${sendFailureText(result)}. Check the address in Settings → Notifications → Notification URL (for ntfy, https://ntfy.sh/your-topic), then press Send test notification again.`,
             });
         }
@@ -147,12 +166,10 @@ export function settingsRoutes(deps) {
             return result.reason === "duplicate-voice-id"
                 ? problem(c, {
                     status: 409,
-                    title: titleOf(409),
                     detail: "This voice ID is already saved for this provider. Use the existing voice, or enter a different voice ID.",
                 })
                 : problem(c, {
                     status: 400,
-                    title: titleOf(400),
                     detail: "This voice cannot be added yet. Fix the highlighted field and try again.",
                     extensions: { fields: [fieldOf(result.reason)] },
                 });
@@ -166,12 +183,10 @@ export function settingsRoutes(deps) {
         return result.reason === "missing"
             ? problem(c, {
                 status: 404,
-                title: titleOf(404),
                 detail: "This voice no longer exists; it may have been deleted. Reload Settings → Voices to see your voices.",
             })
             : problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: "The languages weren't saved. Fix the highlighted field and try again.",
                 extensions: { fields: [fieldOf("unknown-language")] },
             });
@@ -183,7 +198,6 @@ export function settingsRoutes(deps) {
             ? c.body(null, 204)
             : problem(c, {
                 status: 404,
-                title: titleOf(404),
                 detail: "This voice no longer exists; it may have been deleted. Reload Settings → Voices to see your voices.",
             });
     })
@@ -191,7 +205,6 @@ export function settingsRoutes(deps) {
         if (!removeVoice(voiceDeps, c.req.valid("param").id).ok) {
             return problem(c, {
                 status: 404,
-                title: titleOf(404),
                 detail: "This voice no longer exists; it may have been deleted already. Reload the page to see your voices.",
             });
         }

package/dist/edge/http/social.js

@@ -0,0 +1,283 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { projectById } from "../../slices/admission/repo.js";
+import { webhookBody } from "../../slices/notifications/address.js";
+import { sendFailureText } from "../../slices/notifications/send.js";
+import { readNotificationUrl } from "../../slices/notifications/settings.js";
+import { setupSectionNames } from "../../slices/project-templates/setup-sections.js";
+import { waitsForRelease } from "../../slices/social/due.js";
+import { postingExtension, writeExtensionSites } from "../../slices/social/extension.js";
+import { platformLabels } from "../../slices/social/model.js";
+import { postReadyNotice } from "../../slices/social/notice.js";
+import { packFor, postPacks } from "../../slices/social/pack.js";
+import { readPost, writeChoice, writeReddit, writeTextEdit } from "../../slices/social/repo.js";
+import { choiceBody, linkBody, platformSchema, redditBody, resultBody, textBody, } from "../../slices/social/schema.js";
+import { serveMedia } from "../../slices/social/serve.js";
+import { duePosts, fillPost, linksToFind, nextPost, notPostingSentence, reportPost, setPostLink, } from "../../slices/social/service.js";
+import { fileResponse } from "./byte-range.js";
+import { extensionAuth } from "./extension-auth.js";
+import { idString } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
+import { fromSlopifyPage } from "./same-page.js";
+const projectParam = z.object({ projectId: idString });
+const postParam = projectParam.extend({ platform: platformSchema });
+const fileParam = projectParam.extend({
+    file: z
+        .string()
+        .min(1)
+        .max(200)
+        .regex(/^[A-Za-z0-9_-]+$/),
+});
+const nextQuery = z.object({
+    platform: platformSchema,
+    projectId: z.string().min(1).max(200).optional(),
+});
+const dueQuery = z.object({ hours: z.coerce.number().int().min(1).max(48).optional() });
+const sitesBody = z.object({ sites: z.array(platformSchema).max(6) });
+export function socialRoutes(deps) {
+    const { allowOrigin, allowed, refused } = extensionAuth(deps.db);
+    const media = {
+        db: deps.db,
+        paths: deps.paths,
+        reshaper: deps.social?.reshaper,
+        ...(deps.designs === undefined
+            ? {}
+            : {
+                renderDesign: async (designId, format, signal) => {
+                    const drawn = await deps.designs?.renderer.render(designId, format, "png", signal);
+                    return drawn?.ok === true
+                        ? { ok: true, path: drawn.value.path }
+                        : {
+                            ok: false,
+                            sentence: drawn?.message ??
+                                "The design couldn't be drawn. Open it in Designs to check it, then close Copy for YouTube Studio and open it again.",
+                        };
+                },
+            }),
+    };
+    const samePage = (c) => fromSlopifyPage(c, deps.remoteAccess?.remoteHost)
+        ? undefined
+        : problem(c, {
+            status: 403,
+            detail: "For your safety, a project's posts can only be changed from the Slopify page itself. Open Slopify and try again there.",
+        });
+    const answer = (c, projectId) => {
+        const result = postPacks(deps, projectId, deps.clock.now());
+        if (!result.ok)
+            return unknownProject(c);
+        const body = {
+            ...result.packs,
+            extension: postingExtension(deps.db),
+        };
+        return c.json(body);
+    };
+    const refusal = (c, refused) => problem(c, { status: refused.status, detail: refused.sentence });
+    const posting = (c, projectId, platform) => packFor(deps, projectId, platform, deps.clock.now()) === undefined
+        ? problem(c, {
+            status: 404,
+            detail: notPostingSentence(platform),
+        })
+        : undefined;
+    // A post filled at its release time tells the Notification URL, when one is set. Never
+    // awaited: the extension's report doesn't wait on it.
+    const notify = (text, projectId) => {
+        const url = readNotificationUrl(deps.db);
+        const send = deps.sendNotification;
+        if (url === null || send === undefined)
+            return;
+        void send(url, webhookBody(text)).then((sent) => {
+            if (!sent.ok)
+                deps.log.write("warn", "social.notify", { projectId, detail: sendFailureText(sent) });
+        });
+    };
+    const changed = (projectId) => deps.hub.emit(projectId, { type: "project.updated", projectId });
+    return (new Hono()
+        .get("/packs/:projectId", zValidator("param", projectParam, onInvalid), (c) => answer(c, c.req.valid("param").projectId))
+        // The project's own pick for one site: other settings, not posting there ({off: true}),
+        // or back to the template's (null).
+        .put("/packs/:projectId/:platform/choice", zValidator("param", postParam, onInvalid), zValidator("json", choiceBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        if (postPacks(deps, projectId, deps.clock.now()).ok === false)
+            return unknownProject(c);
+        const { choice } = c.req.valid("json");
+        const config = projectById(deps.db, projectId)?.config.social?.[platform];
+        if (choice !== null &&
+            !("off" in choice) &&
+            choice.text === "prompt" &&
+            config?.text !== "prompt")
+            return problem(c, {
+                status: 409,
+                detail: `A post written by a post prompt is a paid step, so it is picked in the template, in Edit template → ${setupSectionNames.youtube}, where Save shows its cost. For this project, pick a free text source in Copy for YouTube Studio → ${platformLabels[platform]} → Settings.`,
+            });
+        writeChoice(deps.db, { projectId, platform }, choice, deps.clock.now());
+        changed(projectId);
+        return answer(c, projectId);
+    })
+        .put("/packs/:projectId/:platform/text", zValidator("param", postParam, onInvalid), zValidator("json", textBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        const missing = posting(c, projectId, platform);
+        if (missing !== undefined)
+            return missing;
+        writeTextEdit(deps.db, { projectId, platform }, c.req.valid("json"), deps.clock.now());
+        changed(projectId);
+        return answer(c, projectId);
+    })
+        .delete("/packs/:projectId/:platform/text", zValidator("param", postParam, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        const missing = posting(c, projectId, platform);
+        if (missing !== undefined)
+            return missing;
+        writeTextEdit(deps.db, { projectId, platform }, null, deps.clock.now());
+        changed(projectId);
+        return answer(c, projectId);
+    })
+        .put("/packs/:projectId/:platform/reddit", zValidator("param", postParam, onInvalid), zValidator("json", redditBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        if (platform !== "reddit")
+            return problem(c, {
+                status: 400,
+                detail: "Only a Reddit post has a subreddit, title and flair. Open the Reddit post instead.",
+            });
+        const missing = posting(c, projectId, platform);
+        if (missing !== undefined)
+            return missing;
+        writeReddit(deps.db, { projectId, platform }, c.req.valid("json").reddit, deps.clock.now());
+        changed(projectId);
+        return answer(c, projectId);
+    })
+        // The post's link, pasted by the person (posted by hand, or the extension missed it); null
+        // removes it, so the post can be filled again.
+        .put("/packs/:projectId/:platform/link", zValidator("param", postParam, onInvalid), zValidator("json", linkBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        const result = setPostLink(deps, projectId, platform, c.req.valid("json").url, deps.clock.now());
+        if (!result.ok)
+            return refusal(c, result);
+        changed(projectId);
+        return answer(c, projectId);
+    })
+        // Fill in <site>: never offered to agents or the assistant (`excluded-routes.ts`).
+        .post("/packs/:projectId/:platform/fill", zValidator("param", postParam, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        const result = fillPost(deps, projectId, platform, deps.clock.now());
+        if (!result.ok)
+            return refusal(c, result);
+        changed(projectId);
+        return c.json({
+            pack: result.pack,
+            waitsForRelease: result.waitsForRelease,
+            url: result.pack.composeUrl,
+        });
+    })
+        .get("/media/:projectId/:file", zValidator("param", fileParam, onInvalid), async (c) => {
+        const { projectId, file } = c.req.valid("param");
+        return served(c, await serveMedia(media, projectId, file, deps.clock.now(), c.req.raw.signal));
+    })
+        // The extension's routes.
+        .options("/ext/*", (c) => {
+        allowOrigin(c, false);
+        return c.body(null, 204);
+    })
+        .get("/ext/next", zValidator("query", nextQuery, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        const { platform, projectId } = c.req.valid("query");
+        const next = nextPost(deps, platform, deps.clock.now(), projectId);
+        if (next === undefined)
+            return problem(c, {
+                status: 404,
+                detail: "Nothing is waiting to be filled on this site. In Slopify, open the project, press Copy for YouTube Studio, then Fill in the site's post.",
+            });
+        changed(next.pack.projectId);
+        return c.json(next);
+    })
+        .get("/ext/packs/:projectId/:platform", zValidator("param", postParam, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        const { projectId, platform } = c.req.valid("param");
+        const pack = packFor(deps, projectId, platform, deps.clock.now());
+        return pack === undefined ? unknownPost(c) : c.json(pack);
+    })
+        .get("/ext/files/:projectId/:file", zValidator("param", fileParam, onInvalid), async (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        const { projectId, file } = c.req.valid("param");
+        return served(c, await serveMedia(media, projectId, file, deps.clock.now(), c.req.raw.signal));
+    })
+        .get("/ext/due", zValidator("query", dueQuery, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        const hours = c.req.valid("query").hours ?? 24;
+        return c.json({ posts: duePosts(deps, deps.clock.now(), hours * 3_600_000) });
+    })
+        .post("/ext/result", zValidator("json", resultBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        const body = c.req.valid("json");
+        const result = reportPost(deps, body, deps.clock.now());
+        if (!result.ok)
+            return refusal(c, result);
+        changed(body.projectId);
+        if (body.state === "filled" && waitsForRelease(body.platform) && result.pack !== undefined)
+            notify(postReadyNotice(result.pack), body.projectId);
+        return c.json({ status: readPost(deps.db, body).state });
+    })
+        .get("/ext/find-links", (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        return c.json({ posts: linksToFind(deps, deps.clock.now()) });
+    })
+        // Which sites the extension may post on, as its options last granted them.
+        .post("/ext/sites", zValidator("json", sitesBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        writeExtensionSites(deps.db, c.req.valid("json").sites, deps.clock.now());
+        return c.json(postingExtension(deps.db));
+    }));
+}
+function served(c, result) {
+    if (!result.ok)
+        return problem(c, { status: result.status, detail: result.sentence });
+    return fileResponse(c, result.path, result.bytes, {
+        "content-type": result.contentType,
+        "content-disposition": `inline; filename="${result.filename.replace(/["\\]/g, "")}"`,
+        "x-content-type-options": "nosniff",
+    });
+}
+function unknownProject(c) {
+    return problem(c, {
+        status: 404,
+        detail: "This project no longer exists. Go back to Projects and open it again.",
+    });
+}
+function unknownPost(c) {
+    return problem(c, {
+        status: 404,
+        detail: "That project no longer posts to this site. In Slopify, open the project's Copy for YouTube Studio and press Fill again.",
+    });
+}