@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/social/reshape.js

@@ -0,0 +1,97 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync, } from "node:fs";
+import { join } from "node:path";
+import { coverCrop } from "../designs/frames.js";
+import { pictureSize } from "../designs/picture-size.js";
+// Pictures cut to a site's shape (Instagram's 4:5), made the first time a post asks for them
+// and kept: free, local, in a child ffmpeg off the server's thread. Never a video: re-encoding
+// a whole video would take as long as rendering it, so a video keeps its shape and the pack
+// warns instead.
+// Raised when the cut changes, so every kept copy is made again.
+const reshapeVersion = 1;
+const frames = {
+    "1:1": { width: 1080, height: 1080 },
+    "4:5": { width: 1080, height: 1350 },
+    "9:16": { width: 1080, height: 1920 },
+    "16:9": { width: 1920, height: 1080 },
+};
+export const socialDir = (paths, projectId) => join(paths.dataDir, "social", projectId);
+// The ffmpeg arguments: scaled to cover the frame, cut around the centre, saved as a JPEG. A
+// picture whose size can't be read is cut by ffmpeg's own cover fit, which centres the same way.
+export function reshapeArgs(input) {
+    const frame = frames[input.shape];
+    const size = `${String(frame.width)}:${String(frame.height)}`;
+    const chain = input.size === undefined
+        ? [`scale=${size}:force_original_aspect_ratio=increase:flags=lanczos`, `crop=${size}`]
+        : ((crop) => [
+            `scale=${String(crop.scaleWidth)}:${String(crop.scaleHeight)}:flags=lanczos`,
+            `crop=${size}:${String(crop.x)}:${String(crop.y)}`,
+        ])(coverCrop(input.size, frame, { x: 0.5, y: 0.5 }));
+    return [
+        ...["-hide_banner", "-nostdin", "-loglevel", "error", "-y", "-i", input.source],
+        ...["-vf", [...chain, "format=yuvj420p"].join(","), "-frames:v", "1", "-q:v", "2"],
+        input.output,
+    ];
+}
+export function createReshaper(deps) {
+    let queue = Promise.resolve();
+    const oneAtATime = (work) => {
+        const next = queue.then(work, work);
+        queue = next.catch(() => undefined);
+        return next;
+    };
+    return {
+        picture: (projectId, source, shape, signal) => oneAtATime(async () => {
+            const stat = statSync(source, { throwIfNoEntry: false });
+            if (stat === undefined || !stat.isFile())
+                return {
+                    ok: false,
+                    sentence: "The picture isn't on disk any more. Close Copy for YouTube Studio and open it again; if it is still missing, make the project's images again.",
+                };
+            const key = createHash("sha256")
+                .update(JSON.stringify([reshapeVersion, source, stat.size, stat.mtimeMs, shape]))
+                .digest("hex")
+                .slice(0, 32);
+            const dir = socialDir(deps.paths, projectId);
+            const target = join(dir, `${key}.jpg`);
+            if (existsSync(target))
+                return { ok: true, path: target };
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            const work = mkdtempSync(join(dir, ".work-"));
+            try {
+                await deps.runFfmpeg({
+                    bin: deps.ffmpeg,
+                    cwd: work,
+                    args: reshapeArgs({
+                        source,
+                        size: pictureSize(readFileSync(source)),
+                        shape,
+                        output: "out.jpg",
+                    }),
+                    signal,
+                    log: deps.log,
+                    onProgress: () => undefined,
+                });
+                renameSync(join(work, "out.jpg"), target);
+                return { ok: true, path: target };
+            }
+            catch (error) {
+                deps.log.write("warn", "social.reshape", {
+                    projectId,
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+                return {
+                    ok: false,
+                    sentence: `The picture couldn't be cut to ${shape} because ffmpeg stopped with an error. Close Copy for YouTube Studio and open it again to try again; if it fails again, use Download diagnostics in Settings and report it.`,
+                };
+            }
+            finally {
+                rmSync(work, { recursive: true, force: true });
+            }
+        }),
+    };
+}
+// A project's kept copies, removed with the project.
+export function dropReshaped(paths, projectId) {
+    rmSync(socialDir(paths, projectId), { recursive: true, force: true });
+}

package/dist/slices/social/rules.js

@@ -0,0 +1,5 @@
+import { socialPlatforms } from "./model.js";
+// Whether any site's post is written by a post prompt: a paid call to the project's text model.
+export function usesPostPrompt(draft) {
+    return socialPlatforms.some((platform) => draft.social?.[platform]?.text === "prompt");
+}

package/dist/slices/social/schema.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { postTextSources, redditPostKinds, reportedStates, socialPlatforms, xTiers, } from "./model.js";
+export const promptNameMax = 200;
+export const customTextMax = 5000;
+export const postTextMax = 50_000;
+export const hashtagsMax = 30;
+export const picturesMax = 35;
+export const designsMax = 10;
+const designId = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z0-9_-]+$/);
+export const postMediaSchema = z
+    .object({
+    video: z.enum(["long", "short"]).optional(),
+    short: z.number().int().min(1).max(99).optional(),
+    thumbnail: z.boolean().optional(),
+    pictures: z.number().int().min(0).max(picturesMax).optional(),
+    designs: z.array(designId).max(designsMax).optional(),
+})
+    .strict();
+export const postChoiceSchema = z
+    .object({
+    text: z.enum(postTextSources),
+    prompt: z.string().max(promptNameMax).optional(),
+    custom: z.string().max(customTextMax).optional(),
+    media: postMediaSchema,
+    hashtags: z.number().int().min(0).max(hashtagsMax),
+    link: z.boolean(),
+})
+    .strict();
+// `config.social` (and Play's `form.social`): absent is no posting.
+export const socialSettingsSchema = z.partialRecord(z.enum(socialPlatforms), postChoiceSchema);
+export const projectPostChoiceSchema = z.union([
+    postChoiceSchema,
+    z.object({ off: z.literal(true) }).strict(),
+]);
+export const subredditMax = 21;
+export const redditFieldsSchema = z
+    .object({
+    subreddit: z
+        .string()
+        .max(subredditMax + 2)
+        .transform((name) => name.trim().replace(/^\/?r\//u, "")),
+    title: z.string().max(300),
+    flair: z.string().max(64),
+    kind: z.enum(redditPostKinds),
+})
+    .strict();
+export const platformSchema = z.enum(socialPlatforms);
+export const xTierSchema = z.enum(xTiers);
+// The page's bodies (`edge/http/social.ts`).
+export const choiceBody = z.object({ choice: projectPostChoiceSchema.nullable() }).strict();
+export const textBody = z
+    .object({ text: z.string().max(postTextMax), base: z.string().max(postTextMax) })
+    .strict();
+export const redditBody = z.object({ reddit: redditFieldsSchema }).strict();
+export const linkBody = z.object({ url: z.string().max(500).nullable() }).strict();
+// The extension's report after a fill. Unknown keys are dropped, so a newer extension's
+// report still reaches an older Slopify.
+export const resultBody = z.object({
+    projectId: z.string().min(1).max(64),
+    platform: platformSchema,
+    item: z.number().int().min(0).max(99).optional(),
+    state: z.enum(reportedStates),
+    url: z.string().max(500).optional(),
+    message: z.string().max(2000).optional(),
+    at: z.iso.datetime().optional(),
+});

package/dist/slices/social/serve.js

@@ -0,0 +1,51 @@
+import { statSync } from "node:fs";
+import { findDownload } from "../storage/downloads.js";
+import { parseMediaFile } from "./media.js";
+import { postPacks } from "./pack.js";
+const gone = "That file isn't in the project's posts any more. Close Copy for YouTube Studio, open it again and press Fill again.";
+// One file of a project's posts, only when one of its posts lists it: the asset as it is, a
+// picture cut to its site's shape (made now the first time), or a design drawn in its format.
+export async function serveMedia(deps, projectId, file, now, signal) {
+    const result = postPacks(deps, projectId, now);
+    const listed = result.ok
+        ? result.packs.packs.flatMap((pack) => pack.media).find((one) => one.file === file)
+        : undefined;
+    const ref = parseMediaFile(file);
+    if (listed === undefined || ref === undefined)
+        return { ok: false, status: 404, sentence: gone };
+    const done = (path) => {
+        const stat = statSync(path, { throwIfNoEntry: false });
+        return stat?.isFile() === true
+            ? {
+                ok: true,
+                path,
+                bytes: stat.size,
+                contentType: listed.contentType,
+                filename: listed.filename,
+            }
+            : { ok: false, status: 404, sentence: gone };
+    };
+    if (ref.kind === "design") {
+        if (deps.renderDesign === undefined)
+            return {
+                ok: false,
+                status: 503,
+                sentence: "Designs can't be drawn in this copy of Slopify. Restart Slopify; if it stays, use Download diagnostics in Settings and report it.",
+            };
+        const drawn = await deps.renderDesign(ref.id, ref.format, signal);
+        return drawn.ok ? done(drawn.path) : { ok: false, status: 404, sentence: drawn.sentence };
+    }
+    const found = findDownload(deps, projectId, ref.asset);
+    if (!found.ok)
+        return { ok: false, status: 404, sentence: gone };
+    if (ref.shape === "original")
+        return done(found.download.path);
+    if (deps.reshaper === undefined)
+        return {
+            ok: false,
+            status: 503,
+            sentence: "Pictures can't be cut to the site's shape in this copy of Slopify. Restart Slopify; if it stays, use Download diagnostics in Settings and report it.",
+        };
+    const cut = await deps.reshaper.picture(projectId, found.download.path, ref.shape, signal);
+    return cut.ok ? done(cut.path) : { ok: false, status: 503, sentence: cut.sentence };
+}

package/dist/slices/social/service.js

@@ -0,0 +1,129 @@
+import { projectById } from "../admission/repo.js";
+import { projectChannelId } from "../channels/repo.js";
+import { setupSectionNames } from "../project-templates/setup-sections.js";
+import { channelSocial } from "./channel.js";
+import { dueAt, readyNow, tooLate, waitsForRelease } from "./due.js";
+import { profileUrl } from "./limits.js";
+import { lookupDue, lookupStart } from "./links.js";
+import { platformLabels, } from "./model.js";
+import { packFor } from "./pack.js";
+import { expireWaiting, takeNext } from "./queue.js";
+import { postsIn, readPost, writeProgress } from "./repo.js";
+import { askFill, pasteLink, reportFill } from "./state.js";
+// A project's settings have no posting editor: its sites come from its template (or Create).
+export function notPostingSentence(platform) {
+    const site = platformLabels[platform];
+    return `This project doesn't post to ${site}. A project's sites come from its template: tick ${site} under Post to in Edit template → ${setupSectionNames.youtube}, or under Post to other sites in Create, for the projects it makes next.`;
+}
+const notPosting = (platform) => ({
+    ok: false,
+    status: 404,
+    sentence: notPostingSentence(platform),
+});
+// The release time a waiting post fills at, read from its pack.
+function releaseOf(deps, projectId, platform, now) {
+    return packFor(deps, projectId, platform, now)?.schedule.at ?? null;
+}
+// Fill in <site>: the post waits for the extension (on a site without a scheduler, for its
+// release time when that is still ahead).
+export function fillPost(deps, projectId, platform, now) {
+    const before = packFor(deps, projectId, platform, now);
+    if (before === undefined)
+        return notPosting(platform);
+    const asked = askFill(readPost(deps.db, { projectId, platform }), platform, now);
+    if (!asked.ok)
+        return { ok: false, status: 409, sentence: asked.sentence };
+    writeProgress(deps.db, { projectId, platform }, asked.progress, now);
+    const pack = packFor(deps, projectId, platform, now) ?? before;
+    return {
+        ok: true,
+        pack,
+        waitsForRelease: !readyNow(platform, pack.schedule.at, now),
+    };
+}
+// The person pasted the post's link, or removed it.
+export function setPostLink(deps, projectId, platform, url, now) {
+    if (packFor(deps, projectId, platform, now) === undefined)
+        return notPosting(platform);
+    const pasted = pasteLink(readPost(deps.db, { projectId, platform }), platform, url, now);
+    if (!pasted.ok)
+        return { ok: false, status: 400, sentence: pasted.sentence };
+    writeProgress(deps.db, { projectId, platform }, pasted.progress, now);
+    return { ok: true };
+}
+const waits = (deps, now) => (post) => waitsForRelease(post.platform) &&
+    !tooLate(post.platform, releaseOf(deps, post.projectId, post.platform, now), now);
+// The extension's next post for a site: the oldest waiting one that can be filled now, of
+// `projectId` when the tab Slopify opened names it.
+export function nextPost(deps, platform, now, projectId) {
+    expireWaiting(deps.db, now, waits(deps, now));
+    for (;;) {
+        const taken = takeNext(deps.db, platform, now, (post) => readyNow(platform, releaseOf(deps, post.projectId, platform, now), now), projectId);
+        if (taken === undefined)
+            return undefined;
+        const pack = packFor(deps, taken.post.projectId, platform, now);
+        if (pack !== undefined)
+            return { pack, waiting: taken.waiting };
+        // The project or its post is gone: it stops waiting, and the next one is taken.
+        writeProgress(deps.db, taken.post, { ...taken.post, state: "none", waitingAt: null }, now);
+    }
+}
+export function reportPost(deps, report, now) {
+    const { projectId, platform } = report;
+    if (projectById(deps.db, projectId) === undefined)
+        return {
+            ok: false,
+            status: 404,
+            sentence: "This project no longer exists in Slopify, so nothing was recorded.",
+        };
+    const reported = reportFill(readPost(deps.db, { projectId, platform }), platform, report, now);
+    if (!reported.ok)
+        return {
+            ok: false,
+            status: reported.reason === "bad-link" ? 400 : 409,
+            sentence: reported.sentence,
+        };
+    writeProgress(deps.db, { projectId, platform }, reported.progress, now);
+    return { ok: true, pack: packFor(deps, projectId, platform, now) };
+}
+// Waiting posts on sites without a scheduler whose release is within `horizonMs` (or passed
+// at most 12 hours ago), for the extension's alarms.
+export function duePosts(deps, now, horizonMs) {
+    return postsIn(deps.db, ["waiting"]).flatMap((post) => {
+        const pack = packFor(deps, post.projectId, post.platform, now);
+        const due = pack === undefined ? undefined : dueAt(post.platform, pack.schedule.at, now, horizonMs);
+        return pack === undefined || due === undefined
+            ? []
+            : [
+                {
+                    projectId: post.projectId,
+                    projectTitle: pack.projectTitle,
+                    platform: post.platform,
+                    at: due.at,
+                    late: due.late,
+                    composeUrl: pack.composeUrl,
+                },
+            ];
+    });
+}
+// Filled or scheduled posts without their link, once they should be on the site, with the
+// profile page to find them on (the channel's account there).
+export function linksToFind(deps, now) {
+    return postsIn(deps.db, ["filled", "scheduled"]).flatMap((post) => {
+        const pack = packFor(deps, post.projectId, post.platform, now);
+        if (pack === undefined || !lookupDue(post, pack.schedule.at, now))
+            return [];
+        const { accounts } = channelSocial(deps.db, projectChannelId(deps.db, post.projectId));
+        const profile = profileUrl(post.platform, accounts);
+        return profile === null || pack.text.trim() === ""
+            ? []
+            : [
+                {
+                    projectId: post.projectId,
+                    platform: post.platform,
+                    profileUrl: profile,
+                    start: lookupStart(pack.text),
+                },
+            ];
+    });
+}

package/dist/slices/social/settings.js

@@ -0,0 +1,21 @@
+import { socialPlatforms } from "./model.js";
+// The settings as a run keeps them: only the sites turned on, each without a prompt name its
+// text source doesn't use or a custom text it doesn't post. None turned on is undefined, so a
+// draft without posting converts to the run it always did.
+export function socialOfForm(form) {
+    if (form === undefined)
+        return undefined;
+    const kept = {};
+    for (const platform of socialPlatforms) {
+        const choice = form[platform];
+        if (choice === undefined)
+            continue;
+        const { prompt, custom, ...rest } = choice;
+        kept[platform] = {
+            ...rest,
+            ...(choice.text === "prompt" && prompt?.trim() ? { prompt: prompt.trim() } : {}),
+            ...(choice.text === "custom" && custom !== undefined ? { custom } : {}),
+        };
+    }
+    return Object.keys(kept).length === 0 ? undefined : kept;
+}

package/dist/slices/social/sources.js

@@ -0,0 +1,114 @@
+import { readFileSync, statSync } from "node:fs";
+import { projectById } from "../admission/repo.js";
+import { projectChannelId } from "../channels/repo.js";
+import { listDesigns } from "../designs/repo.js";
+import { digestKey } from "../rebuild/recipe-digest.js";
+import { isClipPath } from "../rebuild/runtime-export-edit.js";
+import { piecesForRevision } from "../revisions/manifest-repo.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { assetOf } from "../storage/asset-name.js";
+import { contentTypeOf, downloadName, slugOf } from "../storage/downloads.js";
+import { outputPath } from "../storage/layout.js";
+import { outputsOf } from "../storage/repo.js";
+import { uploadPack } from "../studio/pack.js";
+import { videoOf } from "../studio/videos.js";
+import { channelSocial } from "./channel.js";
+import { stripChapters } from "./text.js";
+export function postSources(deps, projectId) {
+    const project = projectById(deps.db, projectId);
+    const pack = uploadPack(deps, projectId);
+    if (project === undefined || !pack.ok)
+        return undefined;
+    const outputs = outputsOf(deps.db, projectId).filter((output) => onDisk(deps, projectId, output));
+    const slug = slugOf(project.title);
+    const source = (output) => ({
+        asset: assetOf(output),
+        filename: downloadName(slug, output),
+        contentType: contentTypeOf(output.path),
+        bytes: output.bytes,
+    });
+    const seconds = (output) => output.durationMs === null ? null : output.durationMs / 1000;
+    const video = outputs.find((output) => output.role === "video");
+    const long = pack.pack.items[0];
+    const shorts = pack.pack.items.filter((item) => item.kind === "short");
+    const shortVideo = (asset) => outputs.find((output) => output.role === "short_video" && assetOf(output) === asset);
+    const thumbnail = long?.thumbnails[0];
+    const thumbnailOutput = outputs.find((output) => output.role === "thumbnail" && assetOf(output) === thumbnail?.asset);
+    const pictures = outputs
+        .filter((output) => output.role === "image" && !isClipPath(output.path))
+        .sort((a, b) => (a.meta.index ?? 0) - (b.meta.index ?? 0))
+        .map((output) => {
+        const alt = altOf(output.meta.prompt);
+        return { ...source(output), ...(alt === undefined ? {} : { alt }) };
+    });
+    const description = stripChapters(long?.description ?? "");
+    const written = {};
+    for (const output of outputs)
+        if (output.role === "social_post" && output.meta.platform !== undefined)
+            written[output.meta.platform] = readFileSync(outputPath(deps.paths, projectId, output.path), "utf8").trim();
+    const longOnYoutube = videoOf(deps.db, projectId, null);
+    return {
+        projectId,
+        title: project.title,
+        config: project.config,
+        youtube: pack.pack,
+        media: {
+            projectId,
+            format: project.config.format,
+            long: video === undefined ? null : { ...source(video), seconds: seconds(video) },
+            shorts: shorts.map((item) => {
+                const output = shortVideo(item.video?.asset);
+                return {
+                    number: item.short ?? 0,
+                    file: output === undefined ? null : { ...source(output), seconds: seconds(output) },
+                };
+            }),
+            thumbnail: thumbnailOutput === undefined ? null : source(thumbnailOutput),
+            pictures,
+            designs: listDesigns(deps.db, { projectId }).map((design) => ({
+                id: design.id,
+                name: design.name,
+            })),
+        },
+        description,
+        summary: digestSummary(deps.db, projectId) ?? firstParagraph(description),
+        written,
+        tags: long?.tags ?? [],
+        shortHashtags: shorts.flatMap((item) => item.tags),
+        youtubeLink: longOnYoutube?.uploadState === "done" ? `https://youtu.be/${longOnYoutube.videoId}` : null,
+        channel: channelSocial(deps.db, projectChannelId(deps.db, projectId)),
+    };
+}
+function onDisk(deps, projectId, output) {
+    return (statSync(outputPath(deps.paths, projectId, output.path), {
+        throwIfNoEntry: false,
+    })?.isFile() === true);
+}
+// A picture's alt text: the first sentence of the prompt that drew it, kept short.
+function altOf(prompt) {
+    const text = prompt?.replace(/\s+/gu, " ").trim() ?? "";
+    if (text === "")
+        return undefined;
+    const sentence = /^.*?[.!?](?=\s|$)/u.exec(text)?.[0] ?? text;
+    return sentence.length <= 300 ? sentence : `${sentence.slice(0, 299)}…`;
+}
+function firstParagraph(text) {
+    return text.split(/\n\s*\n/u)[0]?.trim() ?? "";
+}
+// The summary the current version's keyword digest wrote, when it ran.
+function digestSummary(db, projectId) {
+    const revision = currentRevisionId(db, projectId);
+    if (revision === undefined)
+        return undefined;
+    const piece = piecesForRevision(db, projectId, revision).find((row) => row.key === digestKey && row.selected && row.piece.state === "done");
+    if (piece?.piece.payload == null)
+        return undefined;
+    try {
+        const payload = JSON.parse(piece.piece.payload);
+        const summary = payload.digest?.Slopify_Summary;
+        return typeof summary === "string" && summary.trim() !== "" ? summary.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/slices/social/state.js

@@ -0,0 +1,110 @@
+import { linkExamples, linkPatterns } from "./limits.js";
+import { platformLabels, } from "./model.js";
+export const noProgress = {
+    state: "none",
+    waitingAt: null,
+    filledAt: null,
+    scheduledAt: null,
+    postedAt: null,
+    url: null,
+    message: null,
+    by: null,
+};
+// Fill in <site>: the post waits for the extension. A post already on the site isn't filled
+// again until its link is removed.
+export function askFill(current, platform, now) {
+    if (current.state === "posted")
+        return {
+            ok: false,
+            reason: "posted",
+            sentence: `This post is already on ${platformLabels[platform]}. To post it again, remove its link under the post first, then press Fill in ${platformLabels[platform]}.`,
+        };
+    return {
+        ok: true,
+        progress: { ...noProgress, state: "waiting", waitingAt: now.toISOString() },
+    };
+}
+// The extension took the post, filled it, saw the site schedule or publish it, or stopped.
+export function reportFill(current, platform, report, now) {
+    const site = platformLabels[platform];
+    if (current.state === "none")
+        return {
+            ok: false,
+            reason: "not-asked",
+            sentence: `Nothing was waiting to be filled in ${site} for this project. In Slopify, open the project, press Copy for YouTube Studio, then Fill in ${site}.`,
+        };
+    const url = report.url === undefined || report.url === "" ? null : report.url;
+    if (url !== null && !linkPatterns[platform].test(url))
+        return { ok: false, reason: "bad-link", sentence: badLink(platform) };
+    if (current.state === "posted") {
+        if (report.state !== "posted")
+            return {
+                ok: false,
+                reason: "posted",
+                sentence: `This post is already on ${site}; Slopify keeps it as posted.`,
+            };
+        return { ok: true, progress: { ...current, url: current.url ?? url } };
+    }
+    const at = now.toISOString();
+    const message = report.message === undefined || report.message === "" ? null : report.message;
+    switch (report.state) {
+        case "filling":
+            return { ok: true, progress: { ...current, state: "filling", message: null } };
+        case "filled":
+            return {
+                ok: true,
+                progress: { ...current, state: "filled", filledAt: at, message, by: "extension" },
+            };
+        case "scheduled":
+            return {
+                ok: true,
+                progress: {
+                    ...current,
+                    state: "scheduled",
+                    filledAt: current.filledAt ?? at,
+                    scheduledAt: at,
+                    message,
+                    by: "extension",
+                },
+            };
+        case "posted":
+            return {
+                ok: true,
+                progress: { ...current, state: "posted", postedAt: at, url, message, by: "extension" },
+            };
+        case "failed":
+            return {
+                ok: true,
+                progress: {
+                    ...current,
+                    state: "failed",
+                    message: message ??
+                        `The fill in ${site} stopped without saying why. Press Fill in ${site} again.`,
+                    by: "extension",
+                },
+            };
+    }
+}
+// The person pasted the post's link (posted by hand or the extension missed it), or removed it.
+export function pasteLink(current, platform, url, now) {
+    if (url === null || url.trim() === "")
+        return { ok: true, progress: noProgress };
+    const link = url.trim();
+    if (!linkPatterns[platform].test(link))
+        return { ok: false, reason: "bad-link", sentence: badLink(platform) };
+    return {
+        ok: true,
+        progress: {
+            ...current,
+            state: "posted",
+            postedAt: current.postedAt ?? now.toISOString(),
+            url: link,
+            message: null,
+            by: "person",
+        },
+    };
+}
+function badLink(platform) {
+    const site = platformLabels[platform];
+    return `That isn't a link to a post on ${site}. Open the post on ${site}, copy its address (like ${linkExamples[platform]}) and paste it again.`;
+}