@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/settings/repo.js

@@ -59,6 +59,39 @@ export function readSetting(db, key) {
     const row = db.prepare("SELECT value FROM settings WHERE key = ?").get(key);
     return row === undefined ? undefined : settingRow.parse(row).value;
 }
+// A list of strings that keeps its strings when something else sits among them.
+export const stringListSchema = z
+    .array(z.unknown())
+    .transform((items) => items.filter((one) => typeof one === "string"));
+const warnedSettings = new Set();
+// A row that is absent reads as `fallback`. So does a row that is not JSON or does not fit the
+// schema (a hand-edited database, or a newer Slopify's), which also leaves one warning naming the
+// setting, never its value, so a damaged row neither stops the app nor goes unnoticed. With no
+// `log` to hand the warning goes to the process warnings, once per setting.
+export function readJsonSetting(db, key, schema, fallback, log) {
+    const stored = readSetting(db, key);
+    if (stored === undefined)
+        return fallback;
+    try {
+        const parsed = schema.safeParse(JSON.parse(stored));
+        if (parsed.success)
+            return parsed.data;
+    }
+    catch {
+        // Not JSON: reported below with the rows that parse but do not fit.
+    }
+    const detail = `setting ${key} is not a value this build understands; using the default`;
+    if (log !== undefined)
+        log.write("warn", "settings.invalid", { detail });
+    else if (!warnedSettings.has(key)) {
+        warnedSettings.add(key);
+        process.emitWarning(detail, { code: "SLOPIFY_SETTING_INVALID" });
+    }
+    return fallback;
+}
+export function deleteSetting(db, key) {
+    db.prepare("DELETE FROM settings WHERE key = ?").run(key);
+}
 export function writeSetting(db, key, value) {
     db.prepare("INSERT INTO settings (key, value) VALUES (?, ?)" +
         " ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);

package/dist/slices/settings/tutorial.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { fingerprint } from "../../kernel/runner/work.js";
-import { readSetting, writeSetting } from "./repo.js";
+import { deleteSetting, readSetting, writeSetting } from "./repo.js";
 import { tutorialSessionSchema, tutorialWriteSchema, } from "./tutorial-schema.js";
 export { tutorialSessionSchema, tutorialWriteSchema, } from "./tutorial-schema.js";
 const recordSchema = z
@@ -61,6 +61,6 @@ export function saveTutorial(db, input) {
 }
 export function resetTutorial(db) {
     transact(db, () => {
-        db.prepare("DELETE FROM settings WHERE key = ?").run("tutorial.session");
+        deleteSetting(db, "tutorial.session");
     });
 }

package/dist/slices/settings/voices.js

@@ -1,6 +1,6 @@
 import { isUniqueConstraint } from "../../kernel/db/index.js";
 import { providerById } from "./model.js";
-import { deleteVoice, insertVoice, listVoices, readSetting, updateVoiceLanguages, writeSetting, } from "./repo.js";
+import { deleteSetting, deleteVoice, insertVoice, listVoices, readJsonSetting, stringListSchema, updateVoiceLanguages, writeSetting, } from "./repo.js";
 export const voiceNameMax = 200;
 export const voiceIdMax = 200;
 // A non-empty name and a non-empty voice ID, the ID unique within its provider, names free to
@@ -80,20 +80,12 @@ export function voices(deps) {
 // their ids, so the flag needs no column of its own and travels with a backup.
 export const realPersonVoicesKey = "voices.realPerson";
 export function realPersonVoiceIds(db) {
-    const stored = readSetting(db, realPersonVoicesKey);
-    if (stored === undefined)
-        return new Set();
-    try {
-        const value = JSON.parse(stored);
-        return new Set(Array.isArray(value) ? value.filter((one) => typeof one === "string") : []);
-    }
-    catch {
-        return new Set();
-    }
+    const value = readJsonSetting(db, realPersonVoicesKey, stringListSchema, []);
+    return new Set(value);
 }
 function writeRealPersonVoices(db, ids) {
     if (ids.length === 0)
-        db.prepare("DELETE FROM settings WHERE key = ?").run(realPersonVoicesKey);
+        deleteSetting(db, realPersonVoicesKey);
     else
         writeSetting(db, realPersonVoicesKey, JSON.stringify([...new Set(ids)].sort()));
 }

package/dist/slices/shorts/keep.js

@@ -1,3 +1,4 @@
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { clipBounds } from "./pick.js";
 // Shorts kept through a change of their moments: a count raised or lowered, a new intro or a
 // narration edit that moves the timing. A kept short is remembered by its sentences' text, so
@@ -87,5 +88,5 @@ export function lostMessage(lost, kept) {
         return short === undefined ? `short ${String(at)}` : `short ${String(at)} ("${short.title}")`;
     })
         .join(", ");
-    return `The narration of ${names} changed, so its moment can't be kept. Open Edit project → Shorts and choose Pick a new moment for it or drop it, then Remake.`;
+    return `The narration of ${names} changed, so its moment can't be kept. Untick it under Keep finished shorts in ${editSettings.shorts}, so a new moment is picked for it, save, then use Choose what to make again (in the project's More menu).`;
 }

package/dist/slices/shorts/pick.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { jsonBetween } from "../../kernel/json-answer.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { youtubeTimestamp } from "../youtube/timestamps.js";
 import { shortHashtagsMax, shortHashtagsMin, shortTitleMax } from "./model.js";
 export const shortPickSchema = z.object({
@@ -120,7 +122,7 @@ const answerSchema = z.array(z.object({
     hashtags: z.array(z.string()),
     why: z.string().optional(),
 }));
-const fix = "Try again, or choose another model in Edit project → Providers.";
+const fix = `Try again, or choose another model in ${editSettings.writer}.`;
 // Timing noise: the length rules are checked to the hundredth of a second.
 const tolerance = 0.01;
 // Reads the model's answer and keeps the clips that follow the rules: in range, the right
@@ -128,7 +130,7 @@ const tolerance = 0.01;
 // Not being a JSON array of clips is the one failure; everything else is a problem to tell
 // the model about.
 export function checkPicks(text, sentences, limits) {
-    const parsed = answerSchema.safeParse(jsonArrayOf(text));
+    const parsed = answerSchema.safeParse(jsonBetween(text, "[", "]"));
     if (!parsed.success)
         return {
             ok: false,
@@ -220,23 +222,9 @@ export function checkPicks(text, sentences, limits) {
 export function noPicksMessage(problems, limits) {
     const shortVideo = limits.durationSeconds < limits.minSeconds;
     if (shortVideo)
-        return `The narration is ${String(Math.round(limits.durationSeconds))} seconds long, shorter than the ${String(limits.minSeconds)}-second minimum for a short, so there is nothing to cut. Lower the shortest length in Edit project → Shorts, then Try again.`;
-    return `The AI model didn't pick any clip Slopify could use as a short, twice (${problems[0] ?? "no clips were listed"}). Try again; if it keeps happening, widen the length range in Edit project → Shorts, or choose another model in Edit project → Providers.`;
+        return `The narration is ${String(Math.round(limits.durationSeconds))} seconds long, shorter than the ${String(limits.minSeconds)}-second minimum for a short, so there is nothing to cut. Lower the shortest Length in ${editSettings.shorts}, then Try again.`;
+    return `The AI model didn't pick any clip Slopify could use as a short, twice (${problems[0] ?? "no clips were listed"}). Try again; if it keeps happening, widen the Length range in ${editSettings.shorts}, or choose another model in ${editSettings.writer}.`;
 }
 function round(seconds) {
     return Math.round(seconds * 1000) / 1000;
 }
-// The array in the answer, wherever the model put it: bare, in a ```json fence, or after a
-// sentence of its own.
-function jsonArrayOf(text) {
-    const start = text.indexOf("[");
-    const end = text.lastIndexOf("]");
-    if (start === -1 || end <= start)
-        return undefined;
-    try {
-        return JSON.parse(text.slice(start, end + 1));
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/slices/shorts/prompts.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { jsonBetween } from "../../kernel/json-answer.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 export function imagePromptMessages(brief) {
     const plural = brief.count === 1 ? "prompt" : "prompts";
     return [
@@ -31,11 +33,11 @@ export function imagePromptMessages(brief) {
         },
     ];
 }
-const fix = "Try again, or choose another model in Edit project → Providers.";
+const fix = `Try again, or choose another model in ${editSettings.writer}.`;
 // The reason is the sentence the stage shows; the provider wrapper's `check` asks the model
 // again while attempts remain.
 export function checkImagePrompts(text, count) {
-    const parsed = z.array(z.string()).safeParse(jsonArrayOf(text));
+    const parsed = z.array(z.string()).safeParse(jsonBetween(text, "[", "]"));
     if (!parsed.success)
         return {
             ok: false,
@@ -54,15 +56,3 @@ export function checkImagePrompts(text, count) {
         };
     return { ok: true, prompts };
 }
-function jsonArrayOf(text) {
-    const start = text.indexOf("[");
-    const end = text.lastIndexOf("]");
-    if (start === -1 || end <= start)
-        return undefined;
-    try {
-        return JSON.parse(text.slice(start, end + 1));
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/slices/shorts/render.js

@@ -1,5 +1,6 @@
 import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { editListVersion, } from "../video/edit-list.js";
 import { runFfmpeg } from "../video/ffmpeg.js";
 import { motionFor } from "../video/motion.js";
@@ -46,7 +47,7 @@ export function shortAudioArgs(timeline, start, end, output, options = {}) {
         count += 1;
     }
     if (count === 0 || first === undefined)
-        throw new Error("A short's clip falls outside the narration, so it has no sound to cut. Use Pick different moments in Edit project → Shorts, then Try again.");
+        throw new Error(`A short's clip falls outside the narration, so it has no sound to cut. Use Pick different moments in ${editSettings.shorts}, then Try again.`);
     const joined = Array.from({ length: count }, (_value, at) => `[a${String(at)}]`).join("");
     chains.push(`${joined}concat=n=${String(count)}:v=0:a=1[joined]`);
     const speed = options.speed ?? 1;
@@ -89,7 +90,7 @@ export function shortAudioArgs(timeline, start, end, output, options = {}) {
 // moving as the video's shots move by their place.
 export function shortEditList(input) {
     if (input.images.length === 0)
-        throw new Error("A short has no images to show. Use Make this short again in Edit project → Shorts, then Try again.");
+        throw new Error(`A short has no images to show. Use Make this short again in ${editSettings.shorts}, then Try again.`);
     const total = Math.max(1, Math.round(input.seconds * fps));
     const each = Math.max(1, Math.round(input.imageSeconds * fps));
     const figures = figureFrames(input.figures ?? [], total);
@@ -167,6 +168,7 @@ export async function renderShort(run) {
             }),
             signal: run.signal,
             log: run.log,
+            priority: run.machine?.priority,
             onProgress: () => undefined,
         });
         writeFileSync(join(workspace, "subtitles.ass"), shortCaptionsAss(fasterWords(run.words, speed), {
@@ -205,6 +207,8 @@ export async function renderShort(run) {
             signal: run.signal,
             log: run.log,
             onProgress: run.onProgress,
+            machine: run.machine,
+            notice: run.notice,
         });
     }
     finally {

package/dist/slices/social/channel.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { accountExamples, accountPatterns } from "./limits.js";
+import { platformLabels, socialPlatforms, xTiers, } from "./model.js";
+const accountsSchema = z.partialRecord(z.enum(socialPlatforms), z.string().max(260));
+export function channelSocial(db, channelId) {
+    const row = db.prepare("SELECT x_tier, social_accounts FROM channels WHERE id=?").get(channelId);
+    return channelSocialOf(row?.x_tier, row?.social_accounts);
+}
+// The two columns as a channel row holds them; anything unreadable is Free and no accounts.
+export function channelSocialOf(tier, accounts) {
+    const xTier = xTiers.find((one) => one === tier) ?? "free";
+    try {
+        const parsed = accountsSchema.safeParse(JSON.parse(typeof accounts === "string" ? accounts : "{}"));
+        return { xTier, accounts: parsed.success ? parsed.data : {} };
+    }
+    catch {
+        return { xTier, accounts: {} };
+    }
+}
+// An account name a site wouldn't take, as the sentence the Posting block shows; undefined
+// when every name fits. A blank name is no account.
+export function accountsProblem(accounts) {
+    for (const platform of socialPlatforms) {
+        const name = accounts[platform]?.trim() ?? "";
+        if (name !== "" && !accountPatterns[platform].test(name))
+            return `"${name}" isn't ${/^[AEIOU]/u.test(platformLabels[platform]) ? "an" : "a"} ${platformLabels[platform]} account name. Type it the way ${platformLabels[platform]} shows it (like ${accountExamples[platform]}), without the site's address, then Save.`;
+    }
+    return undefined;
+}
+export function tidyAccounts(accounts) {
+    const tidy = {};
+    for (const platform of socialPlatforms) {
+        const name = accounts[platform]?.trim() ?? "";
+        if (name !== "")
+            tidy[platform] = name;
+    }
+    return tidy;
+}
+export function writeChannelSocial(db, channelId, change) {
+    if (change.xTier !== undefined)
+        db.prepare("UPDATE channels SET x_tier=? WHERE id=?").run(change.xTier, channelId);
+    if (change.accounts !== undefined)
+        db.prepare("UPDATE channels SET social_accounts=? WHERE id=?").run(JSON.stringify(tidyAccounts(change.accounts)), channelId);
+}

package/dist/slices/social/defaults.js

@@ -0,0 +1,17 @@
+// What each site gets when a template turns it on, as the owner chose: the summary with the
+// video on X and LinkedIn, a 4:5 picture carousel on Instagram, the first short on TikTok, the
+// summary with up to four pictures on Bluesky, and a link post on Reddit.
+export const defaultChoices = {
+    x: { text: "summary", media: { video: "long" }, hashtags: 2, link: false },
+    linkedin: { text: "summary", media: { video: "long" }, hashtags: 3, link: false },
+    instagram: { text: "summary", media: { pictures: 10 }, hashtags: 5, link: false },
+    tiktok: { text: "summary", media: { video: "short", short: 1 }, hashtags: 5, link: false },
+    bluesky: { text: "summary", media: { pictures: 4 }, hashtags: 2, link: false },
+    reddit: { text: "none", media: {}, hashtags: 0, link: true },
+};
+export const defaultReddit = (title) => ({
+    subreddit: "",
+    title,
+    flair: "",
+    kind: "link",
+});

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}`;
+    }
+}