@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/keywords/rules.js

@@ -0,0 +1,187 @@
+// What the editor and Play say about the keywords in one body: a `Slopify_` name that is no
+// keyword, a keyword where it can't be filled, and an old name that still works. Browser-safe.
+import { detectSlots } from "../admission/substitute.js";
+import { isReserved, listOf, placeLabels, reservedPrefix, } from "./model.js";
+import { keywordOf, keywordSpecs, legacyNames } from "./specs.js";
+export const keywordProblemKinds = ["unknown", "wrong-place", "legacy"];
+// The same well-formed slot the parser reads (`admission/substitute.ts`).
+const slot = /\{\{([^{}\n]*)\}\}/g;
+// Unknown names already in the stored prompt are let through, so a prompt saved before the
+// prefix was reserved still saves.
+export function keywordProblems(body, place, grandfathered = []) {
+    const problems = [];
+    for (const match of body.matchAll(slot)) {
+        const name = (match[1] ?? "").trim();
+        if (name === "")
+            continue;
+        const at = match.index;
+        const where = `{{${name}}} at ${positionOf(body, at)}`;
+        const spec = keywordOf(name);
+        if (spec === undefined) {
+            if (isReserved(name) && !grandfathered.includes(name))
+                problems.push({
+                    kind: "unknown",
+                    name,
+                    at,
+                    message: `${where} isn't a keyword Slopify fills: names starting with ${reservedPrefix} are Slopify's own. Rename it, e.g. {{${name.slice(reservedPrefix.length) || "Topic"}}}, or insert a keyword from the Insert bar above the text.`,
+                });
+            continue;
+        }
+        const legacy = spec.legacy === name;
+        if (!spec.places.includes(place)) {
+            // An old name outside the picture prompts was plain text before the keywords, and still is.
+            if (legacy)
+                continue;
+            problems.push({ kind: "wrong-place", name, at, message: wrongPlace(where, spec, place) });
+            continue;
+        }
+        if (legacy)
+            problems.push({
+                kind: "legacy",
+                name,
+                at,
+                message: `${where} is the old name of {{${spec.name}}}. It keeps working; use Update to new names in the editor to rename it.`,
+            });
+    }
+    return problems;
+}
+function wrongPlace(where, spec, place) {
+    if (place === "title")
+        return `${where} can't be used in the title: Slopify fills its keywords from the title, so the title can't use them. Remove it, or use a keyword of your own such as {{${spec.name.slice(reservedPrefix.length)}}}.`;
+    const works = listOf(spec.places.map((one) => placeLabels[one]));
+    return `${where} can't be used in ${placeName(place)}: ${why(spec, place)}. Remove it; it works in ${works}.`;
+}
+function why(spec, place) {
+    if ((place === "article" || place === "script") && spec.places.includes("narration"))
+        return "it exists once the article is written, so never in the Article or Script prompt";
+    switch (spec.filler) {
+        case "digest":
+            return place === "article" || place === "script"
+                ? "it is written from the article, which doesn't exist yet when this prompt runs"
+                : "Slopify writes it for pictures, descriptions, shorts and reviews only";
+        case "duration":
+            return "the video's length is known only once the narration is finished";
+        case "scenes":
+        case "appearance":
+            return "it describes one picture, so it works only in picture prompts";
+        default:
+            return "it describes how pictures look, so it works only in picture prompts";
+    }
+}
+function placeName(place) {
+    const label = placeLabels[place];
+    const article = /^[AEIOU]/.test(label) ? "an" : "a";
+    return place === "intro" || place === "outro"
+        ? `${article} ${label} entry`
+        : `${article} ${label} prompt`;
+}
+// The old names a body uses, in first-appearance order.
+export function usesLegacy(body) {
+    const found = [];
+    for (const match of body.matchAll(slot)) {
+        const name = (match[1] ?? "").trim();
+        if (legacyNames.includes(name) && !found.includes(name))
+            found.push(name);
+    }
+    return found;
+}
+// The body with one old name written as its new one. Appearance means the same under both
+// names; Scene's new name turns scenes on for that picture, which is why each is its own choice.
+export function upgradeLegacy(body, which) {
+    const spec = keywordOf(which);
+    if (spec === undefined || spec.legacy !== which)
+        return body;
+    return body.replace(slot, (whole, inside) => inside.trim() === which ? `{{${spec.name}}}` : whole);
+}
+// The place a rendered prompt key fills (`library/slots.ts` names them).
+export function placeOfKey(key, options = {}) {
+    if (key === "article")
+        return options.script === true ? "script" : "article";
+    if (key === "narration" || key === "intro" || key === "outro")
+        return key;
+    if (key === "description" || key === "shorts")
+        return key;
+    if (key === "shortsImage" || key === "referencePrompt" || /^imagePrompts\.\d+$/.test(key))
+        return "image";
+    if (key === "thumbnailPrompt")
+        return "thumbnail";
+    if (key.startsWith("review."))
+        return "review";
+    if (key.startsWith("social."))
+        return "post";
+    return undefined;
+}
+// The parser reports a character offset; a person editing a textarea counts lines and columns.
+export function positionOf(body, at) {
+    const before = body.slice(0, at);
+    const lastBreak = before.lastIndexOf("\n");
+    const line = before.split("\n").length;
+    const column = at - lastBreak;
+    return `line ${String(line)}, column ${String(column)}`;
+}
+// The keywords filled from the facts a run copies when it starts (`facts.ts`).
+const factNames = keywordSpecs
+    .filter((spec) => spec.filler === "facts" && spec.name !== "Slopify_Title")
+    .map((spec) => spec.name);
+// Whether any of the bodies asks for a fact Slopify copies (the title is the project's own).
+export function usesFacts(bodies) {
+    return bodies.some((body) => detectSlots(body).names.some((name) => factNames.includes(name)));
+}
+export function keywordUsesOf(bodies) {
+    let digest;
+    let chapters;
+    let scenes;
+    for (const { field, place, body } of bodies)
+        for (const name of detectSlots(body).names) {
+            const spec = keywordOf(name);
+            if (spec === undefined || spec.name !== name || !spec.places.includes(place))
+                continue;
+            if (spec.filler === "digest")
+                digest ??= field;
+            if (spec.filler === "chapters")
+                chapters ??= field;
+            if (spec.filler === "scenes")
+                scenes ??= field;
+        }
+    return {
+        ...(digest === undefined ? {} : { digest }),
+        ...(chapters === undefined ? {} : { chapters }),
+        ...(scenes === undefined ? {} : { scenes }),
+    };
+}
+// What stops a run: a keyword in a prompt that runs where it can't be filled. A name the person
+// gave a value of their own is theirs (a prompt saved before the prefix was reserved), and an
+// unknown `Slopify_` name stays an ordinary keyword to fill in.
+export function placedProblems(bodies, values) {
+    const problems = [];
+    const seen = new Set();
+    for (const { field, place, body } of bodies)
+        for (const problem of keywordProblems(body, place)) {
+            if (problem.kind !== "wrong-place" || Object.hasOwn(values, problem.name))
+                continue;
+            const key = `${field}\0${problem.name}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            problems.push({
+                field,
+                message: place === "title"
+                    ? problem.message
+                    : `${problem.message} Change the prompt in Library, or pick another one.`,
+            });
+        }
+    return problems;
+}
+// A Text-mode intro or outro is narrated as written, and the release date is only filled into a
+// request as it is sent to the AI model (`rebuild/runtime-keywords.ts`), so a Text entry can't
+// say it.
+export function textEntryProblems(body, category) {
+    return detectSlots(body).names.includes("Slopify_Release_Date")
+        ? [
+            {
+                field: category,
+                message: `{{Slopify_Release_Date}} can't be used in a Text ${category}: Text is narrated as written, and the release date is only filled in when a step asks the AI model. Set this ${category}'s Mode to LLM in Library → Intros & Outros, or remove the keyword.`,
+            },
+        ]
+        : [];
+}

package/dist/slices/keywords/schema.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+// `values.ts`'s KeywordFacts, as a saved config holds it. Edit project sends it back with the
+// rest of the config, so it is bounded like any other part of a draft.
+const text = z.string().max(10_000);
+export const keywordFactsSchema = z.object({
+    channel: text.optional(),
+    series: text.optional(),
+    links: z
+        .array(z.object({ name: text, url: text }))
+        .max(200)
+        .readonly()
+        .optional(),
+    previousVideo: z.object({ title: text, url: text.optional() }).optional(),
+    nextVideo: z.object({ title: text }).optional(),
+    cast: z
+        .array(z.object({ name: text, description: text }))
+        .max(500)
+        .readonly()
+        .optional(),
+    coveredBefore: z.array(text).max(500).readonly().optional(),
+    episode: z.number().int().min(1).optional(),
+    brand: z
+        .object({
+        colours: z.array(text).max(10).readonly(),
+        fonts: z.array(text).max(10).readonly(),
+    })
+        .optional(),
+});

package/dist/slices/keywords/specs.js

@@ -0,0 +1,260 @@
+// The keywords themselves, in the order the Insert bar and the wiki list them.
+import { keywordPlaces } from "./model.js";
+const everywhere = keywordPlaces.filter((place) => place !== "title");
+const afterArticle = everywhere.filter((place) => place !== "article" && place !== "script");
+const pictures = ["image", "thumbnail"];
+const fromDigest = [
+    "image",
+    "thumbnail",
+    "description",
+    "shorts",
+    "review",
+    "post",
+];
+const atStart = "When the run starts; later changes don't change this project.";
+const digestAvailable = "Once the article is written: one shared AI call writes every digest keyword the run uses.";
+const sceneAvailable = "Once the article is written: the scenes call writes one for each picture, even with Scenes from the article off.";
+export const keywordSpecs = [
+    {
+        name: "Slopify_Title",
+        filler: "facts",
+        fills: "The video's title, with its keywords filled in.",
+        example: "How Lighthouses Were Built on Bare Rock",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Channel",
+        filler: "facts",
+        fills: "The name of the project's channel.",
+        example: "Quiet Histories",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Series",
+        filler: "facts",
+        fills: "The channel's series brief from Channels → Edit. A line with an empty brief is left out.",
+        example: "Calm histories of how things were made, one invention at a time.",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Chapters",
+        filler: "chapters",
+        fills: "The article's chapter titles, one per line.",
+        example: "The first lamps\nBuilding on bare rock\nThe last keepers",
+        available: "Once the article is written, so never in the Article or Script prompt.",
+        places: afterArticle,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Links",
+        filler: "facts",
+        fills: "The channel's links, one per line as name and address. In a Description prompt they stay links the page fills when it shows the description.",
+        example: "Website: https://example.com\nPatreon: https://patreon.com/example",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Previous_Video",
+        filler: "facts",
+        fills: "The title and link of the channel's previous video in the same series. A line with none is left out; in a Description prompt it stays the Previous video link.",
+        example: "The Canal Age – https://youtu.be/abc123",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Next_Video",
+        filler: "facts",
+        fills: "The title of the next planned video in the same series and posting plan line. A line with none is left out; in a Description prompt it stays the Next video link.",
+        example: "Tea Clippers and the Race Home",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Release_Date",
+        filler: "release",
+        fills: "The release date from the posting plan. A line with no date is left out; moving the date later doesn't remake anything.",
+        example: "Thursday 22 October 2026",
+        available: "When the step runs.",
+        places: everywhere,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Episode",
+        filler: "facts",
+        fills: "This video's number in its series on the channel.",
+        example: "7",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Duration",
+        filler: "duration",
+        fills: "The finished video's length.",
+        example: "42 min 10 s",
+        available: "Once the narration is finished.",
+        places: ["description", "shorts", "review", "post"],
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Cast",
+        filler: "facts",
+        fills: "The channel's cast members, each with their description. A line with no cast is left out.",
+        example: "Mira: a keeper's daughter who kept the lighthouse logbook",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Covered_Before",
+        filler: "facts",
+        fills: "The titles of the videos the channel already made, so the article avoids repeating them. A line with none is left out.",
+        example: "The Canal Age\nHow Bread Was Baked in Rome",
+        available: atStart,
+        places: everywhere,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Brand",
+        filler: "facts",
+        fills: "The brand kit's caption and title colours and font names. A line with an empty kit is left out.",
+        example: "Colours: #f5c542, #101010. Fonts: Barlow Condensed",
+        available: atStart,
+        places: pictures,
+        cost: "free",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Summary",
+        filler: "digest",
+        fills: "Two or three sentences on what the video covers.",
+        example: "How engineers raised towers on rocks the sea covered twice a day, and how their keepers lived.",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Hook",
+        filler: "digest",
+        fills: "The video's most click-worthy idea.",
+        example: "The rock was under water half of every day. They built on it anyway.",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Thumbnail_Text",
+        filler: "digest",
+        fills: "Two to four words to put on the thumbnail.",
+        example: "BUILT UNDER WATER",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Key_Facts",
+        filler: "digest",
+        fills: "Three to five striking facts from the article, one per line.",
+        example: "The tower stands 35 metres high.\nIts lamp was first lit in 1811.",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Quote",
+        filler: "digest",
+        fills: "One quotable line from the article.",
+        example: "A light is only as good as the person who keeps it.",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Tags",
+        filler: "digest",
+        fills: "Search terms for the video, separated by commas.",
+        example: "lighthouses, engineering history, maritime history, history for sleep",
+        available: digestAvailable,
+        places: fromDigest,
+        cost: "digest",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Scene",
+        filler: "scenes",
+        fills: "What this picture shows: a moment of the article, written for each picture.",
+        example: "A keeper climbs the spiral stair at dusk, a lamp held high.",
+        available: sceneAvailable,
+        places: pictures,
+        cost: "scenes",
+        legacy: "Scene",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Setting",
+        filler: "scenes",
+        fills: "The era and place of this picture's moment, so it stays period-correct.",
+        example: "A rocky Scottish coast, early 19th century, late autumn",
+        available: sceneAvailable,
+        places: pictures,
+        cost: "scenes",
+        batch: 1,
+    },
+    {
+        name: "Slopify_Mood",
+        filler: "scenes",
+        fills: "The feeling of this picture's moment, for its light and colour.",
+        example: "tense",
+        available: sceneAvailable,
+        places: pictures,
+        cost: "scenes",
+        batch: 2,
+    },
+    {
+        name: "Slopify_Appearance",
+        filler: "appearance",
+        fills: "How the video's subject and the characters in this picture look, looked up on the web.",
+        example: "Mira: a tall woman in a wool coat and oilskin hat, a brass lamp at her belt.",
+        available: "Once the article is written: one AI call with web search looks them up.",
+        places: pictures,
+        cost: "appearance",
+        legacy: "Appearance",
+        batch: 1,
+    },
+];
+export const keywordNames = keywordSpecs.map((spec) => spec.name);
+export const legacyNames = keywordSpecs.flatMap((spec) => spec.legacy === undefined ? [] : [spec.legacy]);
+// The keyword a slot name stands for: its own name, or Scene's and Appearance's old ones. Names
+// are case-sensitive, like every slot name.
+export function keywordOf(name) {
+    return keywordSpecs.find((spec) => spec.name === name || spec.legacy === name);
+}
+export function keywordsFor(place) {
+    return keywordSpecs.filter((spec) => spec.places.includes(place));
+}

package/dist/slices/keywords/values.js

@@ -0,0 +1,74 @@
+// The facts a run copies when it starts, for the keywords Slopify fills from them, and how each
+// becomes a keyword's text. Browser-safe.
+import { previousVideoLink } from "../youtube/placeholders.js";
+// The description's own link placeholder for the next video, filled when it is shown like
+// "Previous video".
+export const nextVideoLink = "Next video";
+// Every keyword the facts fill, for one place. A Description prompt keeps the links as the
+// placeholders the description page fills when it shows the description, so they stay live.
+export function factValues(facts, title, place) {
+    const described = place === "description";
+    const links = facts?.links ?? [];
+    const previous = facts?.previousVideo;
+    return {
+        Slopify_Title: title,
+        Slopify_Channel: facts?.channel ?? "",
+        Slopify_Series: facts?.series?.trim() ?? "",
+        Slopify_Links: links
+            .map((link) => `${link.name}: ${described ? `{{${link.name}}}` : link.url}`)
+            .join("\n"),
+        Slopify_Previous_Video: described
+            ? `{{${previousVideoLink}}}`
+            : previous === undefined
+                ? ""
+                : previous.url === undefined || previous.url === ""
+                    ? previous.title
+                    : `${previous.title} – ${previous.url}`,
+        Slopify_Next_Video: described ? `{{${nextVideoLink}}}` : (facts?.nextVideo?.title ?? ""),
+        Slopify_Cast: (facts?.cast ?? [])
+            .map((member) => member.description.trim() === "" ? member.name : `${member.name}: ${member.description}`)
+            .join("\n"),
+        Slopify_Covered_Before: (facts?.coveredBefore ?? []).join("\n"),
+        Slopify_Episode: facts?.episode === undefined ? "" : String(facts.episode),
+        Slopify_Brand: brandText(facts?.brand),
+    };
+}
+function brandText(brand) {
+    if (brand === undefined)
+        return "";
+    const parts = [
+        ...(brand.colours.length === 0 ? [] : [`Colours: ${brand.colours.join(", ")}.`]),
+        ...(brand.fonts.length === 0 ? [] : [`Fonts: ${brand.fonts.join(", ")}.`]),
+    ];
+    return parts.join(" ");
+}
+// The finished length as the description and post prompts say it: "42 min 10 s".
+export function durationText(seconds) {
+    const total = Math.max(0, Math.round(seconds));
+    const hours = Math.floor(total / 3600);
+    const minutes = Math.floor((total % 3600) / 60);
+    const rest = total % 60;
+    return [
+        ...(hours > 0 ? [`${String(hours)} h`] : []),
+        ...(hours > 0 || minutes > 0 ? [`${String(minutes)} min`] : []),
+        `${String(rest)} s`,
+    ].join(" ");
+}
+// The release date as a prompt says it: "Thursday 22 October 2026", in the computer's time zone
+// like every other release time Slopify shows. Blank when the video has no release time.
+export function releaseDateText(at, timeZone) {
+    if (at === undefined || at.trim() === "")
+        return "";
+    const date = new Date(at);
+    if (Number.isNaN(date.getTime()))
+        return "";
+    return new Intl.DateTimeFormat("en-GB", {
+        weekday: "long",
+        day: "numeric",
+        month: "long",
+        year: "numeric",
+        ...(timeZone === undefined ? {} : { timeZone }),
+    })
+        .format(date)
+        .replace(",", "");
+}

package/dist/slices/library/lint.js

@@ -2,14 +2,35 @@
 // restated here - it is admission/substitute.ts's, imported so the editor and the run see
 // the same parse of the same body.
 import { detectSlots } from "../admission/substitute.js";
+import { keywordProblems, positionOf, textEntryProblems } from "../keywords/rules.js";
 import { bodyMax, nameMax } from "./model.js";
-export function lintPrompt(draft) {
-    return lint(draft.name, draft.body);
+// `grandfathered` is the slot names the stored template already has: an unknown `Slopify_`
+// name saved before the prefix was reserved does not stop it saving again.
+export function lintPrompt(draft, grandfathered = []) {
+    return lint(draft.name, draft.body, draft.kind, grandfathered);
 }
-export function lintEntry(draft) {
-    return lint(draft.name, draft.body);
+export function lintEntry(draft, grandfathered = []) {
+    return lint(draft.name, draft.body, draft.category, grandfathered);
 }
-function lint(name, body) {
+// What the editor warns about without refusing the save: a keyword where it can't be filled
+// (Play refuses that run) and an old keyword name.
+export function keywordWarnings(draft) {
+    return [
+        ...keywordProblems(draft.body, placeOf(draft))
+            .filter((problem) => problem.kind !== "unknown")
+            .map((problem) => ({ field: "body", message: problem.message })),
+        ...("category" in draft && draft.mode === "text"
+            ? textEntryProblems(draft.body, draft.category).map((problem) => ({
+                field: "body",
+                message: problem.message,
+            }))
+            : []),
+    ];
+}
+function placeOf(draft) {
+    return "kind" in draft ? draft.kind : draft.category;
+}
+function lint(name, body, place, grandfathered) {
     const fields = [];
     const trimmed = name.trim();
     if (trimmed === "") {
@@ -35,6 +56,9 @@ function lint(name, body) {
     for (const error of detectSlots(body).errors) {
         fields.push({ field: "body", message: describe(error, body) });
     }
+    for (const problem of keywordProblems(body, place, grandfathered))
+        if (problem.kind === "unknown")
+            fields.push({ field: "body", message: problem.message });
     return fields;
 }
 // The parser reports a character offset; a person editing a textarea counts lines and
@@ -50,10 +74,3 @@ function describe(error, body) {
             return `The keyword at ${where} contains a brace. Keywords cannot be placed inside other keywords.`;
     }
 }
-function positionOf(body, at) {
-    const before = body.slice(0, at);
-    const lastBreak = before.lastIndexOf("\n");
-    const line = before.split("\n").length;
-    const column = at - lastBreak;
-    return `line ${String(line)}, column ${String(column)}`;
-}

package/dist/slices/library/model.js

@@ -12,6 +12,8 @@ export const promptKinds = [
     "review",
     // Speaker turns for a multi-voice run (`slices/voices/script.ts`), in place of an article.
     "script",
+    // A post for another site: X, LinkedIn, Instagram, TikTok, Reddit or Bluesky (`slices/social`).
+    "post",
 ];
 export const entryCategories = ["intro", "outro"];
 // The name is what the Play pickers show, so it shares admission's title bound.

package/dist/slices/library/photorealistic.js

@@ -1,4 +1,4 @@
-import { readSetting, writeSetting } from "../settings/repo.js";
+import { deleteSetting, readJsonSetting, stringListSchema, writeSetting, } from "../settings/repo.js";
 import { promptById, promptByName } from "./repo.js";
 // An Image prompt's "Draws photorealistic pictures" tick (Library → Prompts → the prompt).
 // Pictures an image model draws in such a style can pass for real scenes, which is YouTube's
@@ -9,16 +9,8 @@ import { promptById, promptByName } from "./repo.js";
 // for when it is restored.
 export const photorealisticPromptsKey = "library.photorealisticPrompts";
 export function photorealisticPromptIds(db) {
-    const stored = readSetting(db, photorealisticPromptsKey);
-    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, photorealisticPromptsKey, stringListSchema, []);
+    return new Set(value);
 }
 // The prompts as the Library lists them, the ticked ones marked.
 export function withPhotorealistic(db, prompts) {
@@ -34,7 +26,7 @@ export function setPromptPhotorealistic(db, id, on) {
     const others = [...photorealisticPromptIds(db)].filter((one) => one !== id);
     const next = on ? [...others, id].sort() : others;
     if (next.length === 0)
-        db.prepare("DELETE FROM settings WHERE key = ?").run(photorealisticPromptsKey);
+        deleteSetting(db, photorealisticPromptsKey);
     else
         writeSetting(db, photorealisticPromptsKey, JSON.stringify(next));
     return { ok: true };