@gentbajko/slopify 3.16.0 → 3.18.0

package/dist/edge/http/studio.js

@@ -3,7 +3,6 @@ import { join } from "node:path";
 import { Readable } from "node:stream";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
-import { bodyLimit } from "hono/body-limit";
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { derive } from "../../kernel/runner/graph.js";
@@ -16,16 +15,13 @@ import { backfillVideos } from "../../slices/studio/backfill.js";
 import { releaseCalendar } from "../../slices/studio/calendar.js";
 import { playlistUses, studioPlaylistMax, studioUploadUrl, } from "../../slices/studio/model.js";
 import { packItem, uploadPack } from "../../slices/studio/pack.js";
-import { channelPerformance } from "../../slices/studio/performance.js";
 import { writeUploadPick } from "../../slices/studio/pick.js";
 import { postingPlanSchema, readPlan, readStoredPlan, weekdayIn, writePlan, } from "../../slices/studio/plan.js";
 import { leadHoursMax, seriesOf } from "../../slices/studio/plan-model.js";
 import { enqueueFill, fillOnly, readFillQueue, removeFill, } from "../../slices/studio/queue.js";
 import { allReleases, freeSlots, planReleases, readLeadHours, releasesOf, setRelease, swapReleases, writeLeadHours, } from "../../slices/studio/releases.js";
-import { parseStudioExport, readReport, saveReport } from "../../slices/studio/report.js";
-import { statsFromReport } from "../../slices/studio/report-stats.js";
-import { autoCommentKey, bearerToken, exportViewProblem, exportViews, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readExportView, readStudioPlaylists, resetStudioPairing, saveExportView, saveProjectPlaylists, saveRealFootage, saveStudioPlaylists, studioPairing, studioPlaylistsMax, studioPlaylistsProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
-import { abResults, abVariantSchema, projectStats, saveAbResult, saveStats, } from "../../slices/studio/stats.js";
+import { autoCommentKey, bearerToken, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readStudioPlaylists, resetStudioPairing, saveProjectPlaylists, saveRealFootage, saveStudioPlaylists, studioPairing, studioPlaylistsMax, studioPlaylistsProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
+import { abResults, abVariantSchema, saveAbResult } from "../../slices/studio/stats.js";
 import { confirmUpload, doneVideos, forgetVideo, projectVideos, recordedVideos, recordVideo, setChecks, setTaskState, videoIdOf, videoIdPattern, videoOf, waitingTasks, } from "../../slices/studio/videos.js";
 import { setAsideProjects, uploadedProjects } from "../../slices/uploads/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
@@ -89,15 +85,11 @@ const taskResultBody = z.object({
     ok: z.boolean(),
     message: z.string().max(2000),
 });
+// An A/B test's result as Studio shows it; older extensions also send numbers, which are ignored.
 const statsBody = z.object({
     projectId: id,
     short: shortField,
     videoId: z.string().regex(videoIdPattern),
-    impressions: z.number().nonnegative().optional(),
-    ctr: z.number().min(0).max(100).optional(),
-    views: z.number().nonnegative().optional(),
-    averageViewSeconds: z.number().nonnegative().optional(),
-    watchHours: z.number().nonnegative().optional(),
     abVariants: z.array(abVariantSchema).max(3).optional(),
 });
 const backfillBody = z.object({
@@ -192,24 +184,6 @@ export function studioRoutes(deps) {
             .filter((one) => one !== "")
             .toSorted(),
     });
-    // A report and, for each of its videos Slopify made, the project and which upload it is.
-    const reportBody = (channelId) => {
-        const report = readReport(deps.db, channelId);
-        const known = new Map(listProjects(deps.db).flatMap((project) => projectVideos(deps.db, project.id).map((video) => [
-            video.videoId,
-            { projectId: project.id, short: video.short, projectTitle: project.title },
-        ])));
-        return {
-            exportView: readExportView(deps.db, channelId),
-            report,
-            projects: report === null
-                ? {}
-                : Object.fromEntries(report.rows.flatMap((row) => {
-                    const found = known.get(row.videoId);
-                    return found === undefined ? [] : [[row.videoId, found]];
-                })),
-        };
-    };
     const slotChoices = (projectId, series) => freeSlots(deps.db, readPlan(deps.db), whoOf(projectId, series), deps.clock.now(), 9);
     // Finished projects not marked uploaded: the popup's list and the calendar's candidates.
     const finishedProjects = () => {
@@ -469,86 +443,8 @@ export function studioRoutes(deps) {
         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.
-        // Studio's numbers for a project's videos, and every finished A/B test (Library).
-        .get("/stats/:projectId", zValidator("param", projectParam, onInvalid), (c) => c.json({ stats: projectStats(deps.db, c.req.valid("param").projectId) }))
+        // Every finished A/B test (Library).
         .get("/ab-results", (c) => c.json({ results: abResults(deps.db) }))
-        // Channels → YouTube numbers: Studio's Advanced-mode export, imported as the zip Studio
-        // downloads, and which project each of its videos is.
-        .get("/channels/:channelId/report", zValidator("param", z.object({ channelId: id }), onInvalid), (c) => c.json(reportBody(c.req.valid("param").channelId)))
-        .post("/channels/:channelId/report", zValidator("param", z.object({ channelId: id }), onInvalid), bodyLimit({
-        maxSize: 30 * 1024 * 1024,
-        onError: (c) => problem(c, {
-            status: 413,
-            title: titleOf(413),
-            detail: "That file is larger than 30 MB, which a Studio export never is. Export again from Studio's Advanced mode and import the zip it downloads.",
-        }),
-    }), async (c) => {
-        const denied = samePage(c);
-        if (denied !== undefined)
-            return denied;
-        const { channelId } = c.req.valid("param");
-        const parsed = parseStudioExport(new Uint8Array(await c.req.arrayBuffer()), deps.clock.now().toISOString());
-        if (!parsed.ok)
-            return problem(c, { status: 400, title: titleOf(400), detail: parsed.message });
-        saveReport(deps.db, channelId, parsed.report);
-        statsFromReport(deps.db, parsed.report, parsed.report.importedAt);
-        return c.json(reportBody(channelId));
-    })
-        // The Analytics view the extension exports every day for this channel; null forgets it.
-        .put("/channels/:channelId/export-view", zValidator("param", z.object({ channelId: id }), onInvalid), zValidator("json", z.object({ url: z.string().max(4000).nullable() }), onInvalid), (c) => {
-        const denied = samePage(c);
-        if (denied !== undefined)
-            return denied;
-        const { channelId } = c.req.valid("param");
-        const { url } = c.req.valid("json");
-        const wrong = url === null || url.trim() === "" ? undefined : exportViewProblem(url);
-        if (wrong !== undefined)
-            return problem(c, {
-                status: 400,
-                title: titleOf(400),
-                detail: wrong,
-                extensions: { fields: [{ field: "url", message: wrong }] },
-            });
-        saveExportView(deps.db, channelId, url);
-        return c.json(reportBody(channelId));
-    })
-        // The extension: each channel's Analytics view to export.
-        .get("/ext/export-views", (c) => {
-        allowOrigin(c, false);
-        if (!extAllowed(c))
-            return refused(c);
-        return c.json({ views: exportViews(deps.db) });
-    })
-        // The extension exported a channel's view: the zip Studio's Export makes, as Studio sends
-        // it (base64). Saved as an import would be, and each known video's numbers with it.
-        .post("/ext/report", bodyLimit({
-        maxSize: 40 * 1024 * 1024,
-        onError: (c) => problem(c, {
-            status: 413,
-            title: titleOf(413),
-            detail: "Studio's export was larger than Slopify takes (40 MB).",
-        }),
-    }), zValidator("json", z.object({
-        channelId: id,
-        zippedData: z
-            .string()
-            .min(1)
-            .max(40 * 1024 * 1024),
-    }), onInvalid), (c) => {
-        allowOrigin(c, false);
-        if (!extAllowed(c))
-            return refused(c);
-        const { channelId, zippedData } = c.req.valid("json");
-        const now = deps.clock.now().toISOString();
-        const parsed = parseStudioExport(new Uint8Array(Buffer.from(zippedData, "base64url")), now);
-        if (!parsed.ok)
-            return problem(c, { status: 400, title: titleOf(400), detail: parsed.message });
-        saveReport(deps.db, channelId, parsed.report);
-        const videos = statsFromReport(deps.db, parsed.report, now);
-        return c.json({ rows: parsed.report.rows.length, videos });
-    })
-        // Channels → YouTube: the channel's videos on YouTube with Studio's numbers and totals.
-        .get("/channels/:channelId/performance", zValidator("param", z.object({ channelId: id }), onInvalid), (c) => c.json(channelPerformance(deps, c.req.valid("param").channelId)))
         // The YouTube videos a project's uploads became, and their A/B tests.
         .get("/videos/:projectId", zValidator("param", projectParam, onInvalid), (c) => c.json({ videos: projectVideos(deps.db, c.req.valid("param").projectId) }))
         // A video's link pasted in Slopify, for an upload made without the extension; an empty
@@ -797,13 +693,12 @@ export function studioRoutes(deps) {
         setTaskState(deps.db, task, projectId, short ?? null, ok ? "done" : "failed", message);
         return c.json({ ok: true });
     })
-        // Every video on YouTube, for the numbers the extension reads from Studio.
+        // The long videos whose A/B test is running, for the extension to read each result.
         .get("/ext/known-videos", (c) => {
         allowOrigin(c, false);
         if (!extAllowed(c))
             return refused(c);
         return c.json({
-            // The export brings every video's numbers; only an A/B test's result needs a visit.
             videos: doneVideos(deps.db)
                 .filter((video) => video.short === null && video.abState === "started")
                 .map((video) => ({
@@ -864,26 +759,6 @@ export function studioRoutes(deps) {
             return refused(c);
         const body = c.req.valid("json");
         const readAt = deps.clock.now().toISOString();
-        // A visit for the A/B result alone brings no numbers: the export's are kept.
-        const numbers = [
-            body.impressions,
-            body.ctr,
-            body.views,
-            body.averageViewSeconds,
-            body.watchHours,
-        ].some((one) => one !== undefined);
-        if (numbers)
-            saveStats(deps.db, {
-                projectId: body.projectId,
-                short: body.short ?? null,
-                videoId: body.videoId,
-                readAt,
-                impressions: body.impressions ?? null,
-                ctr: body.ctr ?? null,
-                views: body.views ?? null,
-                averageViewSeconds: body.averageViewSeconds ?? null,
-                watchHours: body.watchHours ?? null,
-            });
         if (body.abVariants !== undefined && body.abVariants.length > 1)
             saveAbResult(deps.db, {
                 projectId: body.projectId,

package/dist/edge/mcp/attribution.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { projectsMadeBy } from "../../slices/agents/model.js";
+import { paramsOf, routeOf } from "./route-tool.js";
+const movedBody = z.object({ projectIds: z.array(z.string()) }).loose();
+const trashBody = z
+    .object({ items: z.array(z.object({ kind: z.string(), id: z.string() })) })
+    .loose();
+const savedVersion = z
+    .object({ view: z.object({ revision: z.object({ id: z.string() }) }) })
+    .loose();
+// The projects a tool changed (the one its path names, those its body lists, or those its
+// answer made) and the schedule it changed.
+export function subjectsOf(tool, args, value) {
+    const { path } = routeOf(tool);
+    return {
+        projectIds: projectIdsOf(path, args, value),
+        scheduleId: path.startsWith("/api/schedules/:id") && typeof args.id === "string" ? args.id : null,
+    };
+}
+function projectIdsOf(path, args, value) {
+    if (path.includes("/projects/:id") && typeof args.id === "string")
+        return [args.id];
+    if (paramsOf(path).includes("projectId") && typeof args.projectId === "string")
+        return [args.projectId];
+    if (path.startsWith("/api/trash/:kind/:id"))
+        return args.kind === "project" && typeof args.id === "string" ? [args.id] : [];
+    const moved = movedBody.safeParse(args.body);
+    if (moved.success)
+        return moved.data.projectIds;
+    const trashed = trashBody.safeParse(args.body);
+    if (trashed.success)
+        return trashed.data.items.filter((item) => item.kind === "project").map((item) => item.id);
+    return projectsMadeBy(value);
+}
+export function revisionIdOf(value) {
+    const saved = savedVersion.safeParse(value);
+    return saved.success ? saved.data.view.revision.id : null;
+}

package/dist/edge/mcp/call-route.js

@@ -0,0 +1,203 @@
+import { z } from "zod";
+import { causedBy } from "../../kernel/errors.js";
+import { recordAgentAction } from "../../slices/agents/repo.js";
+import { revisionIdOf, subjectsOf } from "./attribution.js";
+import { fileArg, paramsOf, pathParam, routeOf } from "./route-tool.js";
+const problemSchema = z
+    .object({
+    title: z.string(),
+    detail: z.string().optional(),
+    reason: z.string().optional(),
+    currentRevisionId: z.string().nullable().optional(),
+    fields: z.array(z.object({ field: z.string(), message: z.string() })).optional(),
+    errors: z.array(z.object({ path: z.string(), message: z.string() })).optional(),
+})
+    .loose();
+const querySchema = z.record(z.string(), z.string());
+const bodySchema = z.record(z.string(), z.unknown());
+const keyedBody = z.object({ idempotencyKey: z.string() }).loose();
+export function text(value) {
+    return { content: [{ type: "text", text: value }] };
+}
+export function refusal(value) {
+    return { isError: true, content: [{ type: "text", text: value }] };
+}
+export async function callRoute(deps, tool, args) {
+    const { method, path } = routeOf(tool);
+    const named = paramsOf(path).find((name) => !pathParam.safeParse(args[name]).success);
+    if (named !== undefined)
+        return strayPath(tool, named);
+    const filled = filledPath(path, args);
+    const url = new URL(filled, "http://localhost");
+    // Defense in depth: pathParam already keeps dots and slashes out, but should that rule ever
+    // loosen, a URL that resolves off the tool's own route still never reaches another one.
+    if (url.pathname !== filled)
+        return strayPath(tool, paramsOf(path).join(", "));
+    if (tool.confirm !== undefined && args.confirmed !== true)
+        return refusal(`${(await confirmText(deps, tool, args)) ?? tool.confirm} The web page asks for a second press here: call ${tool.name} again with confirmed: true to go ahead.`);
+    const query = querySchema.safeParse(args.query);
+    if (query.success)
+        for (const [key, value] of Object.entries(query.data))
+            url.searchParams.set(key, value);
+    const response = await deps.api(new Request(url, { method, ...payloadOf(tool, args) }));
+    const type = response.headers.get("content-type") ?? "";
+    const value = response.ok && type.includes("json") && !type.includes("problem")
+        ? await response.json()
+        : undefined;
+    const result = await answerOf(deps, tool, response, value, {
+        called: `${method} ${url.pathname}`,
+        ...projectOf(tool, args),
+    });
+    if (method !== "GET" && tool.unrecorded !== true && response.ok) {
+        const { projectIds, scheduleId } = subjectsOf(tool, args, value);
+        const key = keyedBody.safeParse(args.body);
+        for (const projectId of projectIds.length === 0 ? [null] : projectIds)
+            recordAgentAction(deps.db, {
+                id: deps.ids.next(),
+                projectId,
+                scheduleId,
+                tool: tool.name,
+                title: tool.title,
+                revisionId: revisionIdOf(value),
+                createdAt: deps.clock.now().toISOString(),
+            }, key.success ? key.data.idempotencyKey : undefined);
+    }
+    return result;
+}
+// The consequence with this call's numbers, as the page states it; undefined when they can't
+// be read, and the tool's fixed sentence is said instead.
+async function confirmText(deps, tool, args) {
+    if (tool.confirmFrom === undefined)
+        return undefined;
+    const path = filledPath(tool.confirmFrom.route, args);
+    try {
+        const response = await deps.api(new Request(new URL(path, "http://localhost")));
+        return response.ok ? tool.confirmFrom.text(await response.json()) : undefined;
+    }
+    catch (error) {
+        deps.log.write("warn", "mcp.confirm", {
+            ...projectOf(tool, args),
+            detail: `${tool.name} asked with its fixed consequence: reading ${path} for the numbers failed: ${causedBy(error)}`,
+        });
+        return undefined;
+    }
+}
+// The project a call is about, for its log lines.
+function projectOf(tool, args) {
+    const [projectId] = subjectsOf(tool, args, undefined).projectIds;
+    return projectId === undefined ? {} : { projectId };
+}
+// The route's path with this call's (already checked) parameters in place.
+function filledPath(path, args) {
+    return path.replace(/:(\w+)/g, (_, name) => String(args[name]));
+}
+function strayPath(tool, named) {
+    return refusal(`${tool.name} was refused: ${named} must be an id exactly as Slopify listed it (letters, digits, - and _ only), so the call stays on ${tool.route}. Take the id from the tool that listed it and call ${tool.name} again.`);
+}
+function payloadOf(tool, args) {
+    if (tool.upload !== undefined) {
+        const file = fileArg.parse(args.file);
+        const bytes = new Uint8Array(Buffer.from(file.base64, "base64"));
+        if (tool.upload === "raw")
+            return { body: bytes, headers: { "content-type": file.contentType } };
+        const form = new FormData();
+        form.append("file", new File([bytes], file.name, { type: file.contentType }));
+        return { body: form };
+    }
+    const body = bodySchema.safeParse(args.body);
+    return body.success
+        ? { body: JSON.stringify(body.data), headers: { "content-type": "application/json" } }
+        : {};
+}
+async function answerOf(deps, tool, response, value, call) {
+    const type = response.headers.get("content-type") ?? "";
+    if (!response.ok || type.startsWith("application/problem+json"))
+        return refusal((await failureOf(deps, tool, response, call)).message);
+    if (response.status === 204 || response.body === null)
+        return text("Done.");
+    if (type.startsWith("image/"))
+        return {
+            content: [
+                {
+                    type: "image",
+                    data: Buffer.from(await response.arrayBuffer()).toString("base64"),
+                    mimeType: type.split(";")[0] ?? type,
+                },
+            ],
+        };
+    if (type.includes("json"))
+        return text(JSON.stringify(tool.shape === undefined ? value : tool.shape(value)));
+    if (type.startsWith("text/"))
+        return text(await response.text());
+    return text(`${tool.title} answered with a ${type === "" ? "binary" : type} file of ${response.headers.get("content-length") ?? "unknown"} bytes; read project files with get_project_file.`);
+}
+// One in-process call to the API as the agent, for a tool that makes several of them
+// (import_library, preview_remake_outdated): the JSON it answered, or the refusal worded as a
+// route tool's own call words it.
+export async function callApi(deps, tool, call) {
+    const { method, path, body } = call;
+    const response = await deps.api(new Request(new URL(path, "http://localhost"), {
+        method,
+        ...(body === undefined
+            ? {}
+            : { headers: { "content-type": "application/json" }, body: JSON.stringify(body) }),
+    }));
+    if (response.ok)
+        return { ok: true, value: response.body === null ? undefined : await response.json() };
+    return {
+        ok: false,
+        status: response.status,
+        ...(await failureOf(deps, tool, response, {
+            called: `${method} ${path}`,
+            ...(call.projectId === undefined ? {} : { projectId: call.projectId }),
+        })),
+    };
+}
+// What failed and why, with what to do next, from a refused or failed answer. A refusal that
+// can't be read is logged with the call and the status.
+async function failureOf(deps, tool, response, call) {
+    const type = response.headers.get("content-type") ?? "";
+    if (!type.startsWith("application/problem+json"))
+        return {
+            message: `${tool.title} failed: Slopify answered HTTP ${String(response.status)} without saying why. Call ${tool.name} again; if it keeps failing, use Download diagnostics in Settings and report it.`,
+            fields: [],
+        };
+    let body;
+    let unparsed;
+    try {
+        body = await response.json();
+    }
+    catch (error) {
+        unparsed = error;
+    }
+    const problem = problemSchema.safeParse(body);
+    if (!problem.success) {
+        deps.log.write("warn", "mcp.refusal", {
+            ...(call.projectId === undefined ? {} : { projectId: call.projectId }),
+            detail: `${tool.name}: ${call.called} answered HTTP ${String(response.status)} with a refusal that could not be read: ${unparsed === undefined ? problem.error.message : causedBy(unparsed)}`,
+        });
+        return {
+            message: `${tool.title} was refused, and the refusal could not be read. Call ${tool.name} again; if it keeps happening, use Download diagnostics in Settings and report it.`,
+            fields: [],
+        };
+    }
+    return { message: problemText(tool, problem.data), fields: problem.data.fields ?? [] };
+}
+function problemText(tool, problem) {
+    const { title, detail, reason, currentRevisionId, fields, errors } = problem;
+    // The route's own sentence, except the schema refusal's "reload the page", which fixes
+    // nothing for an agent: it is told which arguments were wrong instead.
+    const lead = errors === undefined
+        ? (detail ?? title)
+        : `${tool.name} was refused: its arguments don't match what Slopify accepts (${errors
+            .map((error) => `${error.path === "" ? "body" : error.path}: ${error.message}`)
+            .join("; ")}). Correct them and call ${tool.name} again.`;
+    const unsaid = (fields ?? []).filter((field) => !lead.includes(field.message));
+    const named = unsaid.length === 0
+        ? ""
+        : ` ${unsaid.map((field) => `${field.field}: ${field.message}`).join(" ")}`;
+    const moved = reason === "conflict" && typeof currentRevisionId === "string"
+        ? ` The project's current revision is ${currentRevisionId}: read it with get_project, then call ${tool.name} once more with baseRevisionId ${currentRevisionId} and a new idempotencyKey.`
+        : "";
+    return `${lead}${named}${moved}`;
+}

package/dist/edge/mcp/excluded-routes.js

@@ -0,0 +1,95 @@
+// The API routes agents are not offered, each with the reason. `tools-parity.test.ts` fails
+// when a route is neither a tool nor listed here.
+const keys = "provider keys are credentials; agents see providers only as configured or missing";
+const backups = "backups (export, import, restore and their schedule) are the person's";
+const updater = "updating Slopify is the person's";
+const hostSetup = "host setup (start at login, CLI paths, the extension's download) is the person's";
+const desktop = "opens a window on the person's desktop; agents read files with get_project_file";
+const listening = "sound and pictures for the person watching the page";
+const personal = "the person's own tutorial, notices and reading state";
+const retired = "retired: answers revision-required; edits go through save_revision";
+const extension = "only the paired Slopify Studio extension calls these";
+const youtube = "acts on YouTube: agents stop at Ready to upload, and uploading is the person's (the extension's queue is filled only from Prepare upload)";
+const cleanup = "every project's cleanup is the person's: Delete all old versions and Clean up everything are in Settings → Backup & storage";
+const notStarted = "not a page action: projects start from Play drafts (start_draft) after their review and estimate";
+export const excludedRoutes = {
+    "GET /api/health": "the MCP connection itself shows Slopify is running",
+    "GET /api/events/global": "a live stream for open pages; agents read needs_attention",
+    "GET /api/events/projects/:id": "a live stream for open pages; agents read needs_attention",
+    "POST /api/storage/files/open": desktop,
+    "POST /api/projects/:id/open-folder": desktop,
+    "POST /api/projects/:id/revisions/:revisionId/:recordId/open-folder": desktop,
+    "GET /api/storage/export/summary": backups,
+    "GET /api/storage/export": backups,
+    "PUT /api/storage/import": backups,
+    "GET /api/backups": backups,
+    "PUT /api/backups": backups,
+    "POST /api/backups/run": backups,
+    "POST /api/storage/old-versions/delete": cleanup,
+    "POST /api/storage/cleanup": cleanup,
+    "GET /api/update/ready": updater,
+    "POST /api/update/activate": updater,
+    "GET /api/update": updater,
+    "DELETE /api/update": updater,
+    "POST /api/update": updater,
+    "POST /api/projects": notStarted,
+    "POST /api/projects/batch": notStarted,
+    "GET /api/projects/:projectId/audio-preview": listening,
+    "GET /api/projects/:projectId/audio-preview/:previewId": listening,
+    "GET /api/projects/:projectId/narration/peaks": listening,
+    "POST /api/auditions": `${listening}; its price is quote_voice_sample`,
+    "POST /api/style-preview": listening,
+    "GET /api/style-preview/:file": listening,
+    "POST /api/document-themes/preview": listening,
+    "GET /api/fonts/:id/file": listening,
+    "PATCH /api/projects/:id/providers": retired,
+    "PUT /api/projects/:id/article": retired,
+    "DELETE /api/projects/:id/images/:outputId": retired,
+    "POST /api/projects/:id/images/:outputId/regenerate": retired,
+    "PATCH /api/projects/:id/subtitles": retired,
+    "GET /api/telemetry/notice": personal,
+    "POST /api/telemetry/notice": personal,
+    "GET /api/tutorial": personal,
+    "PUT /api/tutorial": personal,
+    "DELETE /api/tutorial": personal,
+    "GET /api/whats-new": personal,
+    "POST /api/whats-new/seen": personal,
+    "GET /api/patch-notes": personal,
+    "POST /api/patch-notes/seen": personal,
+    "GET /api/patch-notes/:id": personal,
+    "GET /api/tutorials": personal,
+    "GET /api/tutorials/search": personal,
+    "GET /api/tutorials/:page": personal,
+    "GET /api/providers/first-run": personal,
+    "POST /api/providers/first-run/dismiss": personal,
+    "POST /api/onboarding/dismiss": personal,
+    "GET /api/settings/autostart": hostSetup,
+    "PUT /api/settings/autostart": hostSetup,
+    "POST /api/settings/autostart/answer": hostSetup,
+    "PUT /api/providers/:id/path": hostSetup,
+    "GET /api/studio/extension/:file": hostSetup,
+    "GET /api/providers/key-guides": keys,
+    "PUT /api/providers/:id/key": keys,
+    "POST /api/providers/:id/key/test": keys,
+    "DELETE /api/providers/:id/key": keys,
+    "POST /api/studio/settings/pairing": "makes the extension's pairing token, a credential",
+    "POST /api/studio/packs/:projectId/choose": youtube,
+    "PUT /api/studio/settings/auto-comment": `${youtube}; this posts comments in the person's name`,
+    "POST /api/studio/ext/pair": extension,
+    "GET /api/studio/ext/pack": extension,
+    "POST /api/studio/ext/filled": extension,
+    "POST /api/studio/ext/backfill": extension,
+    "GET /api/studio/ext/ready": extension,
+    "POST /api/studio/ext/upload": `${extension}; ${youtube}`,
+    "POST /api/studio/ext/upload-all": `${extension}; ${youtube}`,
+    "GET /api/studio/ext/packs/:projectId": extension,
+    "GET /api/studio/ext/tasks": extension,
+    "POST /api/studio/ext/task-result": extension,
+    "GET /api/studio/ext/known-videos": extension,
+    "GET /api/studio/ext/recorded-videos": extension,
+    "POST /api/studio/ext/gone": extension,
+    "POST /api/studio/ext/stats": extension,
+    "POST /api/studio/ext/video": extension,
+    "POST /api/studio/ext/video/done": extension,
+    "GET /api/studio/ext/files/:projectId/:asset": extension,
+};