@gentbajko/slopify 3.25.8 → 4.0.0

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 (Prepare upload → 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,55 @@
+// 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 { 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 Library → Prompts → Post, or choose another model in Edit project → Providers.";
+    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);
+}

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. Reload Prepare upload; 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. Reload Prepare upload 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. Reload Prepare upload 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 };
+}