@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/social/due.js

@@ -0,0 +1,36 @@
+import { fillBeforeMs, lateFillMs, nativeSchedule } from "./limits.js";
+// Sites without a scheduler: Instagram, Bluesky and Reddit. A post asked to fill there before
+// its release time waits for it; the extension fills it about two minutes before, and still
+// fills one up to twelve hours late when the browser was closed (flagged late).
+export function waitsForRelease(platform) {
+    return nativeSchedule[platform] === undefined;
+}
+// Whether a waiting post can be filled now: always on a site with a scheduler, and on one
+// without when it has no release time or its time is (nearly) here.
+export function readyNow(platform, releaseAt, now) {
+    if (!waitsForRelease(platform) || releaseAt === null)
+        return true;
+    const at = Date.parse(releaseAt);
+    return !Number.isFinite(at) || at - fillBeforeMs <= now.getTime();
+}
+// A waiting post's fill time within the next `horizonMs`, or a late one still worth filling;
+// undefined for one that is not due, or too late.
+export function dueAt(platform, releaseAt, now, horizonMs) {
+    if (!waitsForRelease(platform) || releaseAt === null)
+        return undefined;
+    const at = Date.parse(releaseAt);
+    if (!Number.isFinite(at))
+        return undefined;
+    const fill = at - fillBeforeMs;
+    const from = now.getTime();
+    if (at < from - lateFillMs || fill > from + horizonMs)
+        return undefined;
+    return { at: new Date(fill).toISOString(), late: at < from };
+}
+// Whether a post that waits for its release time has outlived it.
+export function tooLate(platform, releaseAt, now) {
+    if (!waitsForRelease(platform) || releaseAt === null)
+        return false;
+    const at = Date.parse(releaseAt);
+    return Number.isFinite(at) && at < now.getTime() - lateFillMs;
+}

package/dist/slices/social/extension.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { readJsonSetting, writeSetting } from "../settings/repo.js";
+import { studioPairing } from "../studio/settings.js";
+import { socialPlatforms } from "./model.js";
+const sitesKey = "social.extensionSites";
+const stored = z.object({ sites: z.array(z.enum(socialPlatforms)), at: z.string() });
+// The sites the extension says it may post on, as it last reported them.
+export function writeExtensionSites(db, sites, now) {
+    writeSetting(db, sitesKey, JSON.stringify({ sites: [...new Set(sites)], at: now.toISOString() }));
+}
+export function postingExtension(db) {
+    const seen = readJsonSetting(db, sitesKey, stored, undefined);
+    return {
+        paired: studioPairing(db).origin !== null,
+        sites: seen?.sites ?? null,
+        seenAt: seen?.at ?? null,
+    };
+}

package/dist/slices/social/fit.js

@@ -0,0 +1,115 @@
+// What doesn't fit a site, as plain sentences with the fix. A warning never blocks a fill: the
+// site itself has the last word, and the person may know better. Pure.
+import { limitsFor, nativeSchedule } from "./limits.js";
+import { platformLabels, xTierLabels, } from "./model.js";
+function duration(seconds) {
+    const whole = Math.round(seconds);
+    const hours = Math.floor(whole / 3600);
+    const minutes = Math.floor((whole % 3600) / 60);
+    const rest = whole % 60;
+    const parts = [
+        ...(hours > 0 ? [`${String(hours)} h`] : []),
+        ...(minutes > 0 ? [`${String(minutes)} min`] : []),
+        ...(rest > 0 || whole === 0 ? [`${String(rest)} s`] : []),
+    ];
+    return parts.join(" ");
+}
+export function mediaWarnings(platform, media, tier) {
+    const site = platformLabels[platform];
+    const limits = limitsFor(platform, tier);
+    const warnings = [];
+    const videos = media.filter((one) => one.kind === "video" || one.kind === "short");
+    const stills = media.length - videos.length;
+    if (videos.length > limits.videos)
+        warnings.push({
+            code: "too-many-videos",
+            sentence: `${site} takes one video per post. Keep the video or the short in the post's media, not both.`,
+        });
+    if (stills > limits.pictures)
+        warnings.push({
+            code: "too-many-pictures",
+            sentence: `${site} takes up to ${String(limits.pictures)} pictures per post; this one has ${String(stills)}. The extension puts in the first ${String(limits.pictures)}; pick fewer in the post's media to choose which.`,
+        });
+    if (!limits.mixes && videos.length > 0 && stills > 0)
+        warnings.push({
+            code: "video-and-pictures",
+            sentence: `${site} doesn't take a video and pictures in one post. Keep either the video or the pictures in the post's media.`,
+        });
+    for (const video of videos) {
+        if (video.seconds === undefined || video.seconds <= limits.videoSeconds)
+            continue;
+        const tierHint = platform === "x" && tier === "free"
+            ? ` If the channel's X account has Premium, set it in Channels → Brand → Posting.`
+            : "";
+        warnings.push({
+            code: "video-too-long",
+            sentence: `${platform === "x" ? `X ${xTierLabels[tier]}` : site} takes videos up to ${duration(limits.videoSeconds)}; this one is ${duration(video.seconds)}. Post a short instead, or the link to the video.${tierHint}`,
+        });
+    }
+    if ((platform === "tiktok" || platform === "instagram") && media.length === 0)
+        warnings.push({
+            code: "no-media",
+            sentence: `${site} posts need a video or pictures. Pick a short or pictures in the post's media.`,
+        });
+    if (platform === "tiktok" && videos.some((one) => one.kind === "video" && one.shape === "16:9"))
+        warnings.push({
+            code: "full-video",
+            sentence: "TikTok shows a 16:9 video small, between bars. Pick a short (9:16) in the post's media.",
+        });
+    return warnings;
+}
+export function redditWarnings(fields) {
+    const warnings = [];
+    if (fields.subreddit === "")
+        warnings.push({
+            code: "subreddit-missing",
+            sentence: "The subreddit isn't set, so Reddit will ask where to post. Type it in the post's Subreddit box (like videos, without r/).",
+        });
+    if (fields.title.trim() === "")
+        warnings.push({
+            code: "title-missing",
+            sentence: "Reddit posts need a title. Type one in the post's Title box.",
+        });
+    return warnings;
+}
+// When the post goes out, from the YouTube item it carries: the site's scheduler at the release
+// time, the extension filling it at release time on a site without one, or now.
+export function scheduleFor(platform, releaseAt, now) {
+    const site = platformLabels[platform];
+    if (releaseAt === null)
+        return {
+            schedule: { mode: "now", at: null },
+            warnings: [
+                {
+                    code: "no-release",
+                    sentence: `This project has no release time, so the post goes out when you press Post on ${site}. Give it a time in the project's Release block to post with the video.`,
+                },
+            ],
+        };
+    const at = Date.parse(releaseAt);
+    const ahead = at - now.getTime();
+    if (!Number.isFinite(at) || ahead <= 0)
+        return {
+            schedule: { mode: "now", at: releaseAt },
+            warnings: [
+                {
+                    code: "release-past",
+                    sentence: `The release time has passed, so the post goes out when you press Post on ${site}.`,
+                },
+            ],
+        };
+    const window = nativeSchedule[platform];
+    if (window === undefined)
+        return { schedule: { mode: "at-release", at: releaseAt }, warnings: [] };
+    if (ahead < window.minMs || ahead > window.maxMs)
+        return {
+            schedule: { mode: "now", at: releaseAt },
+            warnings: [
+                {
+                    code: "release-outside-window",
+                    sentence: `${site} schedules posts only ${duration(window.minMs / 1000)} to ${String(Math.round(window.maxMs / 86_400_000))} days ahead, so the extension leaves it to post now. Fill it in again when the release time is within that window, or press Post at the release time.`,
+                },
+            ],
+        };
+    return { schedule: { mode: "native", at: releaseAt }, warnings: [] };
+}

package/dist/slices/social/limits.js

@@ -0,0 +1,186 @@
+// What each site takes, as observed on the site (`checked` is the date, null where it was
+// not seen yet and comes from the site's own help pages). Browser-safe.
+const free = {
+    text: 280,
+    unit: "weighted",
+    pictures: 4,
+    videos: 1,
+    videoSeconds: 140,
+    mixes: true,
+    pictureShape: "original",
+    hashtags: 10,
+    aiLabel: true,
+    checked: null,
+    source: "help.x.com: posting limits, video length",
+};
+const xLimits = {
+    free,
+    premium: { ...free, text: 25_000, videoSeconds: 3 * 3600 },
+    premium_plus: { ...free, text: 25_000, videoSeconds: 3 * 3600 },
+};
+const others = {
+    linkedin: {
+        text: 3000,
+        unit: "characters",
+        pictures: 20,
+        videos: 1,
+        videoSeconds: 15 * 60,
+        mixes: false,
+        pictureShape: "original",
+        hashtags: 5,
+        aiLabel: false,
+        checked: null,
+        source: "linkedin.com/help: share an update, video specifications",
+    },
+    instagram: {
+        text: 2200,
+        unit: "characters",
+        pictures: 20,
+        videos: 1,
+        videoSeconds: 15 * 60,
+        mixes: true,
+        pictureShape: "4:5",
+        hashtags: 30,
+        aiLabel: true,
+        checked: "2026-10-18",
+        source: "Instagram's Create new post dialog (caption counter 0/2,200, crop 4:5)",
+    },
+    tiktok: {
+        text: 4000,
+        unit: "characters",
+        pictures: 35,
+        videos: 1,
+        videoSeconds: 60 * 60,
+        mixes: false,
+        pictureShape: "original",
+        hashtags: 10,
+        aiLabel: true,
+        checked: "2026-10-18",
+        source: "TikTok Studio's upload page (60 min videos, 35 photos, 4000 characters)",
+    },
+    reddit: {
+        text: 40_000,
+        unit: "characters",
+        pictures: 20,
+        videos: 1,
+        videoSeconds: 15 * 60,
+        mixes: false,
+        pictureShape: "original",
+        hashtags: 0,
+        aiLabel: false,
+        checked: null,
+        source: "reddithelp.com: posting images and videos",
+    },
+    bluesky: {
+        text: 300,
+        unit: "graphemes",
+        pictures: 4,
+        videos: 1,
+        videoSeconds: 3 * 60,
+        mixes: false,
+        pictureShape: "original",
+        hashtags: 3,
+        aiLabel: false,
+        checked: "2026-10-18",
+        source: "Bluesky's composer (counter starts at 300); 4 images or one video",
+    },
+};
+export function limitsFor(platform, tier = "free") {
+    return platform === "x" ? xLimits[tier] : others[platform];
+}
+// Reddit's title limit.
+export const redditTitleMax = 300;
+export const subredditPattern = /^[A-Za-z0-9][A-Za-z0-9_]{1,20}$/;
+const minute = 60_000;
+const day = 24 * 60 * minute;
+export const nativeSchedule = {
+    x: { minMs: 5 * minute, maxMs: 540 * day, checked: null },
+    linkedin: { minMs: 60 * minute, maxMs: 90 * day, checked: null },
+    tiktok: { minMs: 15 * minute, maxMs: 10 * day, checked: null },
+};
+// How long before the release time the extension fills a post on a site without a scheduler,
+// and how late it still fills one when the browser was closed.
+export const fillBeforeMs = 2 * minute;
+export const lateFillMs = 12 * 60 * minute;
+// Where each site's post form opens.
+export const composeUrls = {
+    x: "https://x.com/compose/post",
+    linkedin: "https://www.linkedin.com/feed/?shareActive=true",
+    instagram: "https://www.instagram.com/",
+    tiktok: "https://www.tiktok.com/tiktokstudio/upload",
+    reddit: "https://www.reddit.com/submit",
+    bluesky: "https://bsky.app/",
+};
+// The address Fill in <site> opens: the post form with "#slopify-post=<projectId>:<platform>".
+// The extension fills only a post form that carries this mark (or the one its alarm opens at
+// release time, `packages/extension/src/social/messages.ts`), and only that project's post; a
+// post form the person opens themselves is never touched.
+export const fillMark = "slopify-post";
+export function fillUrl(composeUrl, projectId, platform) {
+    return `${composeUrl.replace(/#.*$/, "")}#${fillMark}=${encodeURIComponent(projectId)}:${platform}`;
+}
+// Reddit's submit page takes the title, text and link in its address.
+export function redditSubmitUrl(fields) {
+    const query = new URLSearchParams({ title: fields.title });
+    if (fields.text !== undefined && fields.text !== "")
+        query.set("text", fields.text);
+    if (fields.url !== undefined && fields.url !== "")
+        query.set("url", fields.url);
+    const sub = fields.subreddit === "" ? "" : `/r/${encodeURIComponent(fields.subreddit)}`;
+    return `https://www.reddit.com${sub}/submit?${query.toString()}`;
+}
+// A published post's link on each site, as the person pastes it or the extension reads it.
+export const linkPatterns = {
+    x: /^https:\/\/(?:www\.)?(?:x|twitter)\.com\/[A-Za-z0-9_]{1,15}\/status\/\d+(?:[/?#].*)?$/,
+    linkedin: /^https:\/\/(?:www\.)?linkedin\.com\/(?:feed\/update\/urn:li:[A-Za-z]+:\d+|posts\/[^\s]+)\/?(?:[?#].*)?$/,
+    instagram: /^https:\/\/(?:www\.)?instagram\.com\/(?:[A-Za-z0-9_.]+\/)?(?:p|reel)\/[A-Za-z0-9_-]+\/?(?:[?#].*)?$/,
+    tiktok: /^https:\/\/(?:www\.)?tiktok\.com\/@[A-Za-z0-9_.]+\/(?:video|photo)\/\d+\/?(?:[?#].*)?$/,
+    reddit: /^https:\/\/(?:www\.|old\.|new\.)?reddit\.com\/r\/[A-Za-z0-9_]+\/comments\/[a-z0-9]+(?:\/[^\s]*)?$/,
+    bluesky: /^https:\/\/bsky\.app\/profile\/[^\s/]+\/post\/[a-z0-9]+\/?(?:[?#].*)?$/,
+};
+export const linkExamples = {
+    x: "https://x.com/you/status/…",
+    linkedin: "https://www.linkedin.com/feed/update/urn:li:activity:…",
+    instagram: "https://www.instagram.com/p/…",
+    tiktok: "https://www.tiktok.com/@you/video/…",
+    reddit: "https://www.reddit.com/r/…/comments/…",
+    bluesky: "https://bsky.app/profile/you.bsky.social/post/…",
+};
+// The account names as the channel stores them, each site's own way of writing one.
+export const accountPatterns = {
+    x: /^@?[A-Za-z0-9_]{1,15}$/,
+    linkedin: /^(?:in|company)\/[A-Za-z0-9-_%]{2,100}$/,
+    instagram: /^@?[A-Za-z0-9_.]{1,30}$/,
+    tiktok: /^@?[A-Za-z0-9_.]{2,24}$/,
+    reddit: /^(?:u\/)?[A-Za-z0-9_-]{3,20}$/,
+    bluesky: /^@?[A-Za-z0-9.-]{3,253}$/,
+};
+export const accountExamples = {
+    x: "@yourname",
+    linkedin: "in/your-name",
+    instagram: "yourname",
+    tiktok: "@yourname",
+    reddit: "u/yourname",
+    bluesky: "yourname.bsky.social",
+};
+// The page listing the account's own posts, where the extension finds a post's link.
+export function profileUrl(platform, accounts) {
+    const raw = accounts[platform]?.trim() ?? "";
+    if (raw === "")
+        return null;
+    const bare = raw.replace(/^@/, "").replace(/^u\//, "");
+    switch (platform) {
+        case "x":
+            return `https://x.com/${bare}`;
+        case "linkedin":
+            return `https://www.linkedin.com/${bare}/recent-activity/all/`;
+        case "instagram":
+            return `https://www.instagram.com/${bare}/`;
+        case "tiktok":
+            return `https://www.tiktok.com/@${bare}`;
+        case "reddit":
+            return `https://www.reddit.com/user/${bare}/submitted/`;
+        case "bluesky":
+            return `https://bsky.app/profile/${bare}`;
+    }
+}

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,131 @@
+// 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 { 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 Prepare upload 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 Edit project.`
+                : `Short ${String(number)} isn't rendered yet. Let the Video stage finish, then open Prepare upload 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 in Edit project.");
+        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.`,
+    };
+}