@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/social/links.js

@@ -0,0 +1,21 @@
+// How long after a post went out the extension looks it up on the person's profile, and for
+// how long it keeps looking.
+export const lookupAfterMs = 10 * 60 * 1000;
+export const lookupForMs = 7 * 24 * 60 * 60 * 1000;
+export const lookupStartLength = 40;
+// A filled or scheduled post without its link, once it should be on the site.
+export function lookupDue(progress, releaseAt, now) {
+    if (progress.url !== null)
+        return false;
+    if (progress.state !== "filled" && progress.state !== "scheduled")
+        return false;
+    const from = Date.parse(progress.state === "scheduled" && releaseAt !== null ? releaseAt : (progress.filledAt ?? ""));
+    if (!Number.isFinite(from))
+        return false;
+    const since = now.getTime() - from;
+    return since >= lookupAfterMs && since <= lookupForMs;
+}
+// The post's first characters, as the profile page shows them, to find it among its posts.
+export function lookupStart(text) {
+    return [...text.replace(/\s+/gu, " ").trim()].slice(0, lookupStartLength).join("");
+}

package/dist/slices/social/media.js

@@ -0,0 +1,132 @@
+// Which files a post carries, in the shape its site wants them. Pure: the sources come from
+// the project's outputs (`sources.ts`); a reshaped picture or a design's render is made the
+// first time it is asked for (`reshape.ts`), so listing a pack never draws anything.
+import { editSettings } from "../../kernel/ports/settings-places.js";
+import { limitsFor } from "./limits.js";
+import { platformLabels, } from "./model.js";
+const shapeSlugs = {
+    "1:1": "1x1",
+    "4:5": "4x5",
+    "9:16": "9x16",
+    "16:9": "16x9",
+};
+// A design's format on each site: portrait on Instagram, a story on TikTok, square elsewhere.
+export function designFormatFor(platform) {
+    return platform === "instagram" ? "portrait" : platform === "tiktok" ? "story" : "square";
+}
+const designShapes = {
+    portrait: "4:5",
+    story: "9:16",
+    square: "1:1",
+};
+// The file names the media routes take: the asset itself, `<asset>--4x5` for a reshaped copy,
+// and `design--<id>--<format>` for a design's render.
+export function mediaFile(asset, shape) {
+    return shape === "original" ? asset : `${asset}--${shapeSlugs[shape]}`;
+}
+export function parseMediaFile(file) {
+    const design = /^design--([A-Za-z0-9_-]{1,64})--([a-z0-9]+)$/u.exec(file);
+    if (design !== null) {
+        const format = Object.keys(designShapes).find((one) => one === design[2]);
+        return format === undefined || design[1] === undefined
+            ? undefined
+            : { kind: "design", id: design[1], format: format };
+    }
+    const match = /^([a-z0-9]+(?:-[a-z0-9]+)*)(?:--([0-9]+x[0-9]+))?$/u.exec(file);
+    if (match === null || match[1] === undefined)
+        return undefined;
+    if (match[2] === undefined)
+        return { kind: "asset", asset: match[1], shape: "original" };
+    const shape = Object.keys(shapeSlugs).find((one) => shapeSlugs[one] === match[2]);
+    return shape === undefined ? undefined : { kind: "asset", asset: match[1], shape };
+}
+const url = (projectId, file) => `/api/social/media/${projectId}/${file}`;
+function still(sources, kind, source, shape) {
+    const file = mediaFile(source.asset, shape);
+    const reshaped = shape !== "original";
+    return {
+        kind,
+        file,
+        url: url(sources.projectId, file),
+        filename: reshaped
+            ? `${source.filename.replace(/\.[^.]+$/u, "")}-${shapeSlugs[shape]}.jpg`
+            : source.filename,
+        contentType: reshaped ? "image/jpeg" : source.contentType,
+        bytes: reshaped ? null : source.bytes,
+        shape,
+        ...(source.alt === undefined ? {} : { alt: source.alt }),
+    };
+}
+// The post's files in the order the site shows them: the video first, then the pictures.
+export function mediaFor(platform, choice, sources) {
+    const media = [];
+    const warnings = [];
+    const site = platformLabels[platform];
+    const missing = (sentence) => warnings.push({ code: "media-missing", sentence });
+    const shape = limitsFor(platform).pictureShape;
+    if (choice.video === "long") {
+        if (sources.long === null)
+            missing("The video isn't made yet. Let the Video stage finish (or use Continue the run on the project page), then open Copy for YouTube Studio again.");
+        else
+            media.push({
+                kind: "video",
+                file: sources.long.asset,
+                url: url(sources.projectId, sources.long.asset),
+                filename: sources.long.filename,
+                contentType: sources.long.contentType,
+                bytes: sources.long.bytes,
+                shape: sources.format,
+                ...(sources.long.seconds === null ? {} : { seconds: sources.long.seconds }),
+            });
+    }
+    else if (choice.video === "short") {
+        const number = choice.short ?? 1;
+        const short = sources.shorts.find((one) => one.number === number);
+        if (short?.file == null)
+            missing(short === undefined
+                ? `This project has no short ${String(number)}. Pick another short for ${site} in the post's media, or turn on Shorts in ${editSettings.shorts}.`
+                : `Short ${String(number)} isn't rendered yet. Let the Video stage finish, then open Copy for YouTube Studio again.`);
+        else
+            media.push({
+                kind: "short",
+                file: short.file.asset,
+                url: url(sources.projectId, short.file.asset),
+                filename: short.file.filename,
+                contentType: short.file.contentType,
+                bytes: short.file.bytes,
+                shape: "9:16",
+                ...(short.file.seconds === null ? {} : { seconds: short.file.seconds }),
+            });
+    }
+    if (choice.thumbnail === true) {
+        if (sources.thumbnail === null)
+            missing(`The thumbnail isn't made yet. Let the Thumbnail stage finish, or set Thumbnail source in ${editSettings.extras}.`);
+        else
+            media.push(still(sources, "thumbnail", sources.thumbnail, shape));
+    }
+    const wanted = choice.pictures ?? 0;
+    if (wanted > 0) {
+        if (sources.pictures.length === 0)
+            missing("This project has no pictures yet. Let the Images stage finish, or pick other media for this post.");
+        for (const picture of sources.pictures.slice(0, wanted))
+            media.push(still(sources, "picture", picture, shape));
+    }
+    const format = designFormatFor(platform);
+    for (const id of choice.designs ?? []) {
+        if (!sources.designs.some((design) => design.id === id)) {
+            missing("A design picked for this post is gone or belongs to another project. Pick the post's designs again.");
+            continue;
+        }
+        const file = `design--${id}--${format}`;
+        media.push({
+            kind: "design",
+            file,
+            url: url(sources.projectId, file),
+            filename: `design-${id}-${format}.png`,
+            contentType: "image/png",
+            bytes: null,
+            shape: designShapes[format] ?? "original",
+        });
+    }
+    return { media, warnings };
+}

package/dist/slices/social/model.js

@@ -0,0 +1,75 @@
+// Posting a project's work to X, LinkedIn, Instagram, TikTok, Reddit and Bluesky. Slopify never
+// posts: the Slopify Studio extension fills each site's own post form and the person presses
+// Post. Browser-safe: the project page, Template Studio and the extension read these names.
+export const socialPlatforms = [
+    "x",
+    "linkedin",
+    "instagram",
+    "tiktok",
+    "reddit",
+    "bluesky",
+];
+export const platformLabels = {
+    x: "X",
+    linkedin: "LinkedIn",
+    instagram: "Instagram",
+    tiktok: "TikTok",
+    reddit: "Reddit",
+    bluesky: "Bluesky",
+};
+// Where a post's words come from. "description" is the YouTube description without its
+// chapters, "summary" the article's digest summary, "prompt" a Library prompt of kind "post"
+// (a paid AI call), "custom" a short text with {{Slopify_…}} keywords, "none" no words.
+export const postTextSources = [
+    "description",
+    "summary",
+    "title",
+    "prompt",
+    "custom",
+    "none",
+];
+// The X subscription of the channel's account: it only changes which warnings a post gets.
+export const xTiers = ["free", "premium", "premium_plus"];
+export const xTierLabels = {
+    free: "Free",
+    premium: "Premium",
+    premium_plus: "Premium+",
+};
+export const redditPostKinds = ["link", "text", "media"];
+// Where a post stands. "waiting": the person pressed Fill in <site>; "filling": the extension
+// took it; "filled": the form is filled and waits for the person's Post; "scheduled": the site
+// will post it at the release time; "posted": it is on the site; "failed": the fill stopped.
+export const postStates = [
+    "none",
+    "waiting",
+    "filling",
+    "filled",
+    "scheduled",
+    "posted",
+    "failed",
+];
+// What the extension reports after a fill (`POST /api/social/ext/result`).
+export const reportedStates = ["filling", "filled", "scheduled", "posted", "failed"];
+export const postMediaKinds = ["video", "short", "thumbnail", "picture", "design"];
+export const mediaShapes = ["original", "1:1", "4:5", "9:16", "16:9"];
+// How the post meets the release time: the site's own scheduler set to it, the extension
+// filling it when it is due (the person presses Post), or posted when the person presses it.
+export const scheduleModes = ["native", "at-release", "now"];
+export const warningCodes = [
+    "text-cut",
+    "too-many-pictures",
+    "video-too-long",
+    "video-and-pictures",
+    "no-media",
+    "subreddit-missing",
+    "title-missing",
+    "release-past",
+    "release-outside-window",
+    "no-release",
+    "media-missing",
+    "text-missing",
+    "full-video",
+    "too-many-videos",
+    "text-too-long",
+    "link-missing",
+];

package/dist/slices/social/notice.js

@@ -0,0 +1,19 @@
+import { platformLabels } from "./model.js";
+// The button the person presses on each site to post.
+const postButton = {
+    x: "Post",
+    linkedin: "Post",
+    instagram: "Share",
+    tiktok: "Post",
+    reddit: "Post",
+    bluesky: "Publish",
+};
+// The Notification URL's message when the extension filled a post at its release time on a site
+// without a scheduler: the person presses the button, Slopify never does.
+export function postReadyNotice(pack) {
+    const site = platformLabels[pack.platform];
+    return {
+        headline: `Ready to post on ${site}: ${pack.projectTitle}`,
+        detail: `The Slopify Studio extension filled the post in your browser. Open the ${site} tab and press ${postButton[pack.platform]}; Slopify never posts by itself.`,
+    };
+}

package/dist/slices/social/pack.js

@@ -0,0 +1,176 @@
+import { projectById } from "../admission/repo.js";
+import { render } from "../admission/substitute.js";
+import { fillWith } from "../keywords/fill.js";
+import { keywordOf } from "../keywords/specs.js";
+import { factValues } from "../keywords/values.js";
+import { defaultReddit } from "./defaults.js";
+import { mediaWarnings, redditWarnings, scheduleFor } from "./fit.js";
+import { composeUrls, limitsFor, redditSubmitUrl } from "./limits.js";
+import { mediaFor } from "./media.js";
+import { platformLabels, socialPlatforms, } from "./model.js";
+import { postsOf } from "./repo.js";
+import { postSources } from "./sources.js";
+import { countFor, fitText, hashtagsFor } from "./text.js";
+// The settings a site's post is made with: the project's own pick, else its template's. Off
+// for this project, or a site neither turned on, has none.
+export function choiceOf(settings, record, platform) {
+    const own = record?.choice ?? null;
+    if (own !== null)
+        return "off" in own ? undefined : { choice: own, chosenHere: true };
+    const base = settings?.[platform];
+    return base === undefined ? undefined : { choice: base, chosenHere: false };
+}
+// Every site the project posts to, each with its post as Prepare upload shows it and the
+// extension fills it. A project with no posting settings and no picks of its own has none.
+export function postPacks(deps, projectId, now) {
+    const project = projectById(deps.db, projectId);
+    if (project === undefined)
+        return { ok: false, reason: "unknown-project" };
+    const records = postsOf(deps.db, projectId);
+    const settings = project.config.social;
+    const wanted = socialPlatforms.filter((platform) => choiceOf(settings, records.find((one) => one.platform === platform), platform) !== undefined);
+    if (wanted.length === 0)
+        return { ok: true, packs: { projectId, packs: [] } };
+    const sources = postSources(deps, projectId);
+    if (sources === undefined)
+        return { ok: false, reason: "unknown-project" };
+    const packs = wanted.flatMap((platform) => {
+        const record = records.find((one) => one.platform === platform && one.item === 0);
+        const pack = buildPack(sources, platform, record, now);
+        return pack === undefined ? [] : [pack];
+    });
+    return { ok: true, packs: { projectId, packs } };
+}
+export function packFor(deps, projectId, platform, now) {
+    const result = postPacks(deps, projectId, now);
+    return result.ok ? result.packs.packs.find((pack) => pack.platform === platform) : undefined;
+}
+function bodyFor(sources, choice, platform) {
+    switch (choice.text) {
+        case "description":
+            return sources.description;
+        case "summary":
+            return sources.summary;
+        case "title":
+            return sources.title;
+        case "prompt":
+            return sources.written[platform] ?? "";
+        case "custom":
+            return customText(sources, choice.custom ?? "");
+        case "none":
+            return "";
+    }
+}
+// The person's own words with their fields and the keywords Slopify fills: the facts copied
+// when the run started, and the summary. A keyword with no value leaves its line out.
+function customText(sources, custom) {
+    const own = render(custom, sources.config.values);
+    const values = {
+        ...factValues(sources.config.keywordFacts, sources.title, "description"),
+        Slopify_Summary: sources.summary,
+    };
+    const filled = fillWith(own, (name) => keywordOf(name)?.name === name
+        ? Object.hasOwn(values, name)
+            ? (values[name] ?? "")
+            : ""
+        : undefined);
+    return filled.ok ? filled.text.trim() : own.trim();
+}
+function buildPack(sources, platform, record, now) {
+    const picked = choiceOf(sources.config.social, record, platform);
+    if (picked === undefined)
+        return undefined;
+    const { choice } = picked;
+    const site = platformLabels[platform];
+    const tier = sources.channel.xTier;
+    const limits = limitsFor(platform, tier);
+    const warnings = [];
+    const { media, warnings: mediaMissing } = mediaFor(platform, choice.media, sources.media);
+    warnings.push(...mediaMissing, ...mediaWarnings(platform, media, tier));
+    const body = bodyFor(sources, choice, platform);
+    if (choice.text !== "none" && body === "")
+        warnings.push({ code: "text-missing", sentence: missingText(choice, site) });
+    const link = choice.link ? sources.youtubeLink : null;
+    if (choice.link && link === null)
+        warnings.push({
+            code: "link-missing",
+            sentence: "The YouTube link isn't known yet, so the post goes without it. It is added once the video is on YouTube (Copy for YouTube Studio → Fill in YouTube Studio, or paste the video's link there).",
+        });
+    const hashtags = hashtagsFor([sources.tags, sources.shortHashtags], Math.min(choice.hashtags, limits.hashtags));
+    const fitted = fitText({ body, link, hashtags }, limits, site);
+    if (fitted.notice !== undefined)
+        warnings.push({ code: "text-cut", sentence: fitted.notice });
+    const edit = record?.textEdit ?? null;
+    const text = edit ?? fitted.text;
+    const used = countFor(text, limits.unit);
+    if (edit !== null && used > limits.text)
+        warnings.push({
+            code: "text-too-long",
+            sentence: `The text is ${String(used)} characters; ${site} takes ${String(limits.text)}. Shorten it in the post's text box, or press Reset to go back to the written text.`,
+        });
+    const main = media.find((one) => one.kind === "short" || one.kind === "video");
+    const shortNumber = main?.kind === "short" ? (choice.media.short ?? 1) : undefined;
+    const item = shortNumber === undefined
+        ? sources.youtube.items[0]
+        : sources.youtube.items.find((one) => one.kind === "short" && one.short === shortNumber);
+    const release = scheduleFor(platform, item?.scheduleAt ?? null, now);
+    warnings.push(...release.warnings);
+    const reddit = platform === "reddit"
+        ? (record?.reddit ?? defaultReddit(sources.title.slice(0, 300)))
+        : undefined;
+    if (reddit !== undefined)
+        warnings.push(...redditWarnings(reddit));
+    return {
+        projectId: sources.projectId,
+        projectTitle: sources.title,
+        platform,
+        item: 0,
+        choice,
+        chosenHere: picked.chosenHere,
+        text,
+        generated: fitted.text,
+        edited: edit !== null,
+        count: { used, max: limits.text, unit: limits.unit },
+        hashtags,
+        link,
+        media,
+        aiLabel: limits.aiLabel && media.length > 0,
+        schedule: release.schedule,
+        ...(reddit === undefined ? {} : { reddit }),
+        ...(platform === "x" ? { xTier: tier } : {}),
+        composeUrl: reddit === undefined
+            ? composeUrls[platform]
+            : redditSubmitUrl({
+                subreddit: reddit.subreddit,
+                title: reddit.title,
+                ...(reddit.kind === "text" ? { text } : {}),
+                ...(reddit.kind === "link" && sources.youtubeLink !== null
+                    ? { url: sources.youtubeLink }
+                    : {}),
+            }),
+        warnings,
+        status: {
+            state: record?.state ?? "none",
+            url: record?.url ?? null,
+            message: record?.message ?? null,
+            at: record === undefined
+                ? null
+                : (record.postedAt ?? record.scheduledAt ?? record.filledAt ?? record.waitingAt),
+            by: record?.by ?? null,
+        },
+    };
+}
+function missingText(choice, site) {
+    switch (choice.text) {
+        case "prompt":
+            return `The ${site} post isn't written yet. It is written by the post prompt after the video's description; let the run finish, or use Continue the run on the project page.`;
+        case "description":
+        case "summary":
+            return `There is no description to post yet. Let the Video stage write the YouTube description, or pick another text source for ${site}.`;
+        case "custom":
+            return `The post's own text is empty. Type it in the post's settings, or pick another text source for ${site}.`;
+        case "title":
+        case "none":
+            return `The post has no text. Pick a text source for ${site}.`;
+    }
+}

package/dist/slices/social/post-prompt.js

@@ -0,0 +1,56 @@
+// The request that writes a post for another site with a Library prompt of kind "post" (or the
+// built-in one), and the check its answer must pass. Pure.
+import { editSettings } from "../../kernel/ports/settings-places.js";
+import { limitsFor } from "./limits.js";
+import { platformLabels } from "./model.js";
+import { countFor } from "./text.js";
+// Changing it changes every post written with the built-in prompt, so it ships with a new
+// recipe operation version.
+export const defaultPostPrompt = "Write one post that makes people want to watch the video. Use the article's own facts, open with its most striking one, and write the way people write on this site.";
+// A post written by a prompt is held to the site's limit, and never longer than this: a post,
+// not an article.
+const writtenMax = 3000;
+// The limit a written post must keep: the site's free limit (X Premium's longer posts are the
+// person's to write), at most `writtenMax`.
+export function postTarget(platform) {
+    const limits = limitsFor(platform);
+    return { platform, max: Math.min(limits.text, writtenMax), unit: limits.unit };
+}
+export function postMessages(input) {
+    const site = platformLabels[input.target.platform];
+    return [
+        {
+            role: "system",
+            content: [
+                `You write one ${site} post about a narrated video, from its article.`,
+                input.instruction.trim() === "" ? defaultPostPrompt : input.instruction.trim(),
+                `Keep it within ${String(input.target.max)} characters as ${site} counts them.`,
+                "Leave out hashtags and links: they are added after you.",
+                "Answer with the post's text and nothing else.",
+            ].join("\n\n"),
+        },
+        {
+            role: "user",
+            content: [`Video: ${input.title}`, `Article:\n\n${input.article}`].join("\n\n"),
+        },
+    ];
+}
+// The post as it is kept: without quotes around it.
+export function postText(answer) {
+    const trimmed = answer.trim();
+    const quoted = /^(["“'])([\s\S]*)(["”'])$/u.exec(trimmed);
+    return (quoted?.[2] ?? trimmed).trim();
+}
+// Why an answer can't be kept, or undefined when it can. A failed check is a failed attempt,
+// which the provider wrapper asks again while attempts remain.
+export function checkPost(answer, target) {
+    const site = platformLabels[target.platform];
+    const text = postText(answer);
+    const fix = `Use Try again; if it keeps happening, shorten what the post prompt asks for in Prompts → Post, or choose another model in ${editSettings.writer}.`;
+    if (text === "")
+        return `The AI model sent back an empty ${site} post. ${fix}`;
+    const used = countFor(text, target.unit);
+    if (used > target.max)
+        return `The AI model's ${site} post is ${String(used)} characters; it may be at most ${String(target.max)}. ${fix}`;
+    return undefined;
+}

package/dist/slices/social/queue.js

@@ -0,0 +1,31 @@
+import { platformLabels } from "./model.js";
+import { postsIn, writeProgress } from "./repo.js";
+// A post waits for the extension at most this long after Fill in <site> was pressed, unless
+// its site has no scheduler and it waits for its release time (`due.ts`).
+export const waitingMs = 24 * 60 * 60 * 1000;
+// Posts left waiting longer than a day stop waiting, with the sentence that says why.
+export function expireWaiting(db, now, waitsForRelease) {
+    for (const post of postsIn(db, ["waiting"])) {
+        if (waitsForRelease(post))
+            continue;
+        const age = now.getTime() - Date.parse(post.waitingAt ?? "");
+        if (Number.isFinite(age) && age <= waitingMs)
+            continue;
+        const site = platformLabels[post.platform];
+        writeProgress(db, post, {
+            ...post,
+            state: "failed",
+            message: `Fill in ${site} waited a day without the Slopify Studio extension taking it. Open ${site} in the browser where the extension is paired and allowed to post there, then press Fill in ${site} again.`,
+        }, now);
+    }
+}
+// The oldest waiting post for a site that can be filled now (of `projectId` when the tab Slopify
+// opened names one); it becomes "filling" so another tab of the site doesn't take it too.
+export function takeNext(db, platform, now, readyNow, projectId) {
+    const waiting = postsIn(db, ["waiting"], platform).filter((post) => (projectId === undefined || post.projectId === projectId) && readyNow(post));
+    const [first] = waiting;
+    if (first === undefined)
+        return undefined;
+    writeProgress(db, first, { ...first, state: "filling", message: null }, now);
+    return { post: first, waiting: waiting.length - 1 };
+}

package/dist/slices/social/repo.js

@@ -0,0 +1,133 @@
+import { postStates, socialPlatforms, } from "./model.js";
+import { projectPostChoiceSchema, redditFieldsSchema } from "./schema.js";
+import { noProgress } from "./state.js";
+const columns = "project_id,platform,item,choice_json,text_edit,text_base,reddit_json,state,waiting_at,filled_at,scheduled_at,posted_at,url,message,by,updated_at";
+const text = (value) => (typeof value === "string" ? value : null);
+function json(value, parse) {
+    if (typeof value !== "string")
+        return null;
+    try {
+        return parse(JSON.parse(value)) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function toRecord(row) {
+    const platform = socialPlatforms.find((one) => one === row.platform);
+    const state = postStates.find((one) => one === row.state) ?? "none";
+    if (platform === undefined || typeof row.project_id !== "string")
+        return undefined;
+    const by = row.by === "extension" || row.by === "person" ? row.by : null;
+    return {
+        projectId: row.project_id,
+        platform,
+        item: typeof row.item === "number" ? row.item : 0,
+        choice: json(row.choice_json, (raw) => {
+            const parsed = projectPostChoiceSchema.safeParse(raw);
+            return parsed.success ? parsed.data : undefined;
+        }),
+        textEdit: text(row.text_edit),
+        textBase: text(row.text_base),
+        reddit: json(row.reddit_json, (raw) => {
+            const parsed = redditFieldsSchema.safeParse(raw);
+            return parsed.success ? parsed.data : undefined;
+        }),
+        state,
+        waitingAt: text(row.waiting_at),
+        filledAt: text(row.filled_at),
+        scheduledAt: text(row.scheduled_at),
+        postedAt: text(row.posted_at),
+        url: text(row.url),
+        message: text(row.message),
+        by,
+        updatedAt: text(row.updated_at),
+    };
+}
+function blank(key) {
+    return {
+        ...noProgress,
+        projectId: key.projectId,
+        platform: key.platform,
+        item: key.item ?? 0,
+        choice: null,
+        textEdit: null,
+        textBase: null,
+        reddit: null,
+        updatedAt: null,
+    };
+}
+export function readPost(db, key) {
+    const row = db
+        .prepare(`SELECT ${columns} FROM social_posts WHERE project_id=? AND platform=? AND item=?`)
+        .get(key.projectId, key.platform, key.item ?? 0);
+    return (row === undefined ? undefined : toRecord(row)) ?? blank(key);
+}
+export function postsOf(db, projectId) {
+    return db
+        .prepare(`SELECT ${columns} FROM social_posts WHERE project_id=? ORDER BY platform, item`)
+        .all(projectId)
+        .flatMap((row) => toRecord(row) ?? []);
+}
+// Every post in one of these states, oldest first (by when it was asked to fill).
+export function postsIn(db, states, platform) {
+    const marks = states.map(() => "?").join(",");
+    const params = [...states];
+    let where = `state IN (${marks})`;
+    if (platform !== undefined) {
+        where += " AND platform=?";
+        params.push(platform);
+    }
+    return db
+        .prepare(`SELECT ${columns} FROM social_posts WHERE ${where} ORDER BY coalesce(waiting_at, updated_at), rowid`)
+        .all(...params)
+        .flatMap((row) => toRecord(row) ?? []);
+}
+const writable = [
+    "choice_json",
+    "text_edit",
+    "text_base",
+    "reddit_json",
+    "state",
+    "waiting_at",
+    "filled_at",
+    "scheduled_at",
+    "posted_at",
+    "url",
+    "message",
+    "by",
+];
+function upsert(db, key, fields, now) {
+    const names = writable.filter((name) => Object.hasOwn(fields, name));
+    const values = names.map((name) => fields[name] ?? null);
+    const updates = [
+        ...names.map((name) => `${name}=excluded.${name}`),
+        "updated_at=excluded.updated_at",
+    ];
+    db.prepare(`INSERT INTO social_posts (project_id,platform,item,${[...names, "updated_at"].join(",")})
+     VALUES (?,?,?,${[...names, "updated_at"].map(() => "?").join(",")})
+     ON CONFLICT(project_id,platform,item) DO UPDATE SET ${updates.join(",")}`).run(key.projectId, key.platform, key.item ?? 0, ...values, now.toISOString());
+}
+export function writeChoice(db, key, choice, now) {
+    upsert(db, key, { choice_json: choice === null ? null : JSON.stringify(choice) }, now);
+}
+// The person's text and the generated text it was edited from; null goes back to the
+// generated text.
+export function writeTextEdit(db, key, edit, now) {
+    upsert(db, key, { text_edit: edit?.text ?? null, text_base: edit?.base ?? null }, now);
+}
+export function writeReddit(db, key, fields, now) {
+    upsert(db, key, { reddit_json: JSON.stringify(fields) }, now);
+}
+export function writeProgress(db, key, progress, now) {
+    upsert(db, key, {
+        state: progress.state,
+        waiting_at: progress.waitingAt,
+        filled_at: progress.filledAt,
+        scheduled_at: progress.scheduledAt,
+        posted_at: progress.postedAt,
+        url: progress.url,
+        message: progress.message,
+        by: progress.by,
+    }, now);
+}