@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/social/service.js

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

package/dist/slices/social/settings.js

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

package/dist/slices/social/sources.js

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

package/dist/slices/social/state.js

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

package/dist/slices/social/text.js

@@ -0,0 +1,149 @@
+// A post's words: counted the way each site counts them, cut to fit at a sentence, with the
+// hashtags and link at the end. Pure and browser-safe: Prepare upload's live counter uses it.
+import { parseTimestamp } from "../youtube/timestamps.js";
+const urlPattern = /https?:\/\/[^\s]+/gu;
+// X counts a link as 23 characters, whatever its length.
+const xUrlWeight = 23;
+// X counts these code points once; every other (CJK, emoji) twice.
+const xLightRanges = [
+    [0, 4351],
+    [8192, 8205],
+    [8208, 8223],
+    [8242, 8247],
+];
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const pictographic = /\p{Extended_Pictographic}/u;
+function xWeight(text) {
+    let total = 0;
+    for (const { segment } of segmenter.segment(text)) {
+        if (pictographic.test(segment)) {
+            total += 2;
+            continue;
+        }
+        for (const char of segment) {
+            const code = char.codePointAt(0) ?? 0;
+            total += xLightRanges.some(([low, high]) => code >= low && code <= high) ? 1 : 2;
+        }
+    }
+    return total;
+}
+export function countFor(text, unit) {
+    switch (unit) {
+        case "weighted": {
+            const links = text.match(urlPattern) ?? [];
+            return xWeight(text.replace(urlPattern, "")) + links.length * xUrlWeight;
+        }
+        case "graphemes":
+            return [...segmenter.segment(text)].length;
+        case "characters":
+            return text.length;
+    }
+}
+// The body, then the link and hashtags, each part on its own paragraph. A body too long is cut
+// at the last sentence that still fits, else at the last word with "…"; the link and hashtags
+// are never cut, but dropped (hashtags first) when even they don't fit.
+export function fitText(input, limits, siteName) {
+    const body = input.body.trim();
+    const tagLine = input.hashtags.join(" ");
+    const join = (parts) => parts.filter((part) => part !== "").join("\n\n");
+    const count = (text) => countFor(text, limits.unit);
+    const whole = join([body, input.link ?? "", tagLine]);
+    if (count(whole) <= limits.text)
+        return { text: whole, used: count(whole) };
+    for (const tail of [[input.link ?? "", tagLine], [input.link ?? ""], []]) {
+        const tailText = join(tail);
+        const room = limits.text - (tailText === "" ? 0 : count(`\n\n${tailText}`));
+        if (room <= 0)
+            continue;
+        const cut = cutBody(body, room, count);
+        if (cut === "" && body !== "")
+            continue;
+        const text = join([cut, ...tail]);
+        const dropped = tail.length === 2
+            ? ""
+            : tail.length === 1
+                ? " and its hashtags"
+                : ", its hashtags and the link";
+        return {
+            text,
+            used: count(text),
+            notice: `The text was cut to fit ${siteName}'s ${String(limits.text)} characters${dropped}. Shorten it in the post's text box, or pick a shorter text source.`,
+        };
+    }
+    const text = cutBody(body, limits.text, count);
+    return {
+        text,
+        used: count(text),
+        notice: `The text was cut to fit ${siteName}'s ${String(limits.text)} characters. Shorten it in the post's text box.`,
+    };
+}
+function cutBody(body, room, count) {
+    if (count(body) <= room)
+        return body;
+    const sentences = body.match(/[^.!?\n]+(?:[.!?]+["')\]]*|\n+|$)/gu) ?? [body];
+    let kept = "";
+    for (const sentence of sentences) {
+        const next = kept + sentence;
+        if (count(next.trimEnd()) > room)
+            break;
+        kept = next;
+    }
+    if (kept.trim() !== "")
+        return kept.trim();
+    const words = body.split(/\s+/u);
+    let line = "";
+    for (const word of words) {
+        const next = line === "" ? word : `${line} ${word}`;
+        if (count(`${next}…`) > room)
+            break;
+        line = next;
+    }
+    return line === "" ? "" : `${line}…`;
+}
+// Hashtags for a post: the description's tags, then the shorts' hashtags, each written once as
+// a #Word without spaces or punctuation, at most `count`.
+export function hashtagsFor(sources, count) {
+    if (count <= 0)
+        return [];
+    const seen = new Set();
+    const tags = [];
+    for (const raw of sources.flat()) {
+        const word = raw
+            .replace(/^#+/u, "")
+            .split(/[^\p{L}\p{N}_]+/u)
+            .map((part, index) => (index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)))
+            .join("");
+        if (word === "" || /^\d+$/u.test(word))
+            continue;
+        const key = word.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        tags.push(`#${word}`);
+        if (tags.length >= count)
+            break;
+    }
+    return tags;
+}
+// The YouTube description without what only YouTube uses: its chapter lines and their heading,
+// and the hashtag lines at the end (the post gets its own).
+export function stripChapters(description) {
+    const lines = description.replace(/\r\n?/gu, "\n").split("\n");
+    const isChapter = (line) => {
+        const match = /^(\S+)\s+\S/u.exec(line.trim());
+        return match !== null && parseTimestamp(match[1] ?? "") !== undefined;
+    };
+    const kept = lines.filter((line, index) => {
+        if (isChapter(line))
+            return false;
+        const heading = /^(?:chapters|timestamps|contents)\s*:?\s*$/iu.test(line.trim());
+        return !(heading && isChapter(lines[index + 1] ?? ""));
+    });
+    const trailing = (line) => line.trim() === "" || /^(?:\s*#[\p{L}\p{N}_]+\s*)+$/u.test(line);
+    while (kept.length > 0 && trailing(kept.at(-1) ?? ""))
+        kept.pop();
+    return kept
+        .join("\n")
+        .replace(/\n{3,}/gu, "\n\n")
+        .trim();
+}

package/dist/slices/storage/arrange.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmdirSync, statSync, writeFileSync, } from "node:fs";
 import { basename, dirname, extname, join } from "node:path";
 import { pickedShortsOf } from "../shorts/clips.js";
+import { notTemplateSample } from "../template-studio/repo.js";
 import { backupsFolderName, projectDir, renderCacheFolder } from "./layout.js";
 // The file in each project folder that says which project it is, for when the database and
 // the folders disagree (a restored database, a folder renamed by hand). Reconcile keeps it.
@@ -20,7 +21,8 @@ export function arrangeKeys(db) {
         (SELECT count(*)||':'||COALESCE(max(a.id),'') FROM project_assets a WHERE a.project_id=p.id) AS assets,
         (SELECT count(*)||':'||COALESCE(max(o.id),'') FROM outputs o WHERE o.project_id=p.id) AS legacy,
         (SELECT count(*)||':'||COALESCE(max(r.id),'') FROM revision_outputs r WHERE r.project_id=p.id AND r.selected=1 AND r.revision_id=h.revision_id) AS current
-       FROM projects p LEFT JOIN project_heads h ON h.project_id=p.id`)
+       FROM projects p LEFT JOIN project_heads h ON h.project_id=p.id
+       WHERE ${notTemplateSample("p")}`)
         .all())
         keys.set(String(row.id), [
             `layout ${layoutVersion}`,

package/dist/slices/storage/assets.js

@@ -1,5 +1,6 @@
 import { closeSync, fchmodSync, fstatSync, fsyncSync, mkdirSync, openSync, rmSync, writeFileSync, } from "node:fs";
 import { basename, dirname, isAbsolute, relative, sep } from "node:path";
+import { errorText, internalError } from "../../kernel/errors.js";
 import { redact } from "../../kernel/log.js";
 import { outputPath } from "./layout.js";
 export function allocateAsset(deps, projectId, filename) {
@@ -10,7 +11,7 @@ export function allocateAsset(deps, projectId, filename) {
     const absolutePath = outputPath(deps.paths, projectId, path);
     const directory = outputPath(deps.paths, projectId, `assets/${id}`);
     if (dirname(absolutePath) !== directory)
-        throw new Error("Slopify hit an internal error (a file name to save is not a plain file name). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error(internalError("a file name to save is not a plain file name"));
     mkdirSync(outputPath(deps.paths, projectId, "assets"), { recursive: true, mode: 0o700 });
     mkdirSync(directory, { mode: 0o700 });
     return { id, projectId, path, absolutePath };
@@ -20,7 +21,7 @@ export function sealAsset(deps, pending) {
     try {
         const stats = fstatSync(file);
         if (!stats.isFile())
-            throw new Error("Slopify hit an internal error (a saved file is not a regular file). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error(internalError("a saved file is not a regular file"));
         fchmodSync(file, 0o600);
         fsyncSync(file);
         return {
@@ -58,7 +59,7 @@ export function discardPreparedAssets(deps, assets) {
             const filename = basename(asset.path);
             requireBasename(filename);
             if (asset.path !== `assets/${asset.id}/${filename}`) {
-                throw new Error("Slopify hit an internal error (a prepared file is not in its allocated directory). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error(internalError("a prepared file is not in its allocated directory"));
             }
             const directory = outputPath(deps.paths, asset.projectId, `assets/${asset.id}`);
             const registered = deps.db
@@ -68,7 +69,7 @@ export function discardPreparedAssets(deps, assets) {
                 if (row.id === asset.id)
                     return true;
                 if (typeof row.path !== "string")
-                    throw new Error("Slopify hit an internal error (a saved file has no path). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+                    throw new Error(internalError("a saved file has no path"));
                 const inside = relative(directory, outputPath(deps.paths, asset.projectId, row.path));
                 return (inside === "" ||
                     (inside !== ".." && !inside.startsWith(`..${sep}`) && !isAbsolute(inside)));
@@ -92,17 +93,14 @@ function requireBasename(filename) {
         }) ||
         /[. ]$/.test(filename) ||
         /^(?:con|prn|aux|nul|conin\$|conout\$|com[1-9¹²³]|lpt[1-9¹²³])(?:\.|$)/i.test(filename))
-        throw new Error("Slopify hit an internal error (a file name to save is not allowed on every system). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-}
-function messageOf(error) {
-    return error instanceof Error ? error.message : String(error);
+        throw new Error(internalError("a file name to save is not allowed on every system"));
 }
 function warnCleanup(deps, projectId, error) {
     try {
-        deps.log.write("warn", "asset.cleanup", { projectId, detail: messageOf(error) });
+        deps.log.write("warn", "asset.cleanup", { projectId, detail: errorText(error) });
     }
     catch (loggingError) {
         // A full disk can prevent both cleanup and file logging; preserve the write error.
-        process.emitWarning(redact(`asset.cleanup ${projectId}: ${messageOf(error)}; logging failed: ${messageOf(loggingError)}`));
+        process.emitWarning(redact(`asset.cleanup ${projectId}: ${errorText(error)}; logging failed: ${errorText(loggingError)}`));
     }
 }