@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/schedules/topics.js

@@ -1,14 +1,18 @@
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
+import { errorText } from "../../kernel/errors.js";
+import { jsonBetween } from "../../kernel/json-answer.js";
 import { liveProject } from "../admission/repo.js";
 import { defaultChannelId } from "../channels/model.js";
 import { projectChannels, scheduleChannel } from "../channels/repo.js";
 import { channelVideoTitles } from "../channels/videos.js";
-import { readSetting, writeSetting } from "../settings/repo.js";
+import { readJsonSetting, writeSetting } from "../settings/repo.js";
+import { notTemplateSample } from "../template-studio/repo.js";
 import { scheduleById } from "./repo.js";
 import { heldTopicEditSchema, heldTopicSchema, queueMax, topicMoveSchema, topicQueueSchema, topicTitleSchema, topicTransferSchema, } from "./schema.js";
 import { newTopics } from "./similar.js";
-import { templateKeywords, topicRowProblems } from "./topic-list.js";
+import { scheduleKeywords, topicRowProblems } from "./topic-list.js";
+import { pinTopic, rankedItems, saveScores, scoreTopics } from "./topic-scores.js";
 // A schedule that finds its own topics asks an LLM whenever its queue holds fewer than
 // `keepAtLeast`. Only one generation per schedule runs at a time: a lease on the schedule row
 // (`topics_generating_at`) is taken before the LLM is asked and cleared after, so a tick and a
@@ -129,26 +133,40 @@ async function ask(deps, schedule, options) {
     catch (error) {
         if (options.signal?.aborted === true)
             return { ok: false, reason: "failed", message: "Slopify was closing." };
-        const detail = error instanceof Error ? error.message : String(error);
+        const detail = errorText(error);
         return fail(`${llm.provider} (${llm.model}) did not answer: ${detail.trim().slice(0, 300)}. Check it in Settings → Providers, or pick another LLM under Edit → Topic generation.`);
     }
     const suggested = parseTopics(answer);
     if (suggested.length === 0)
         return fail(`${llm.provider} (${llm.model}) answered without a list of topics. Try again, or pick another LLM under Edit → Topic generation.`);
+    // Scored outside the transaction: search may take seconds, and never holds the database.
+    const scores = schedule.topicScoring === "off"
+        ? undefined
+        : await scoreTopics(deps, schedule.topicScoring, newTopics(suggested, known), known, template?.document.form.language ?? "en", options.signal);
     return transact(deps.db, () => {
         const current = scheduleById(deps.db, schedule.id);
         if (current === undefined || current.deletedAt !== null)
             return { ok: false, reason: "not-found", message: "This schedule no longer exists." };
         // Checked again against what is there now: a topic added while the LLM was thinking counts.
-        const fresh = newTopics(suggested, knownTitles(deps, schedule.id)).slice(0, Math.max(0, Math.min(wanted, queueMax - current.items.length)));
+        const candidates = newTopics(suggested, knownTitles(deps, schedule.id));
+        // With scoring, the best-scored are kept; without, the LLM's own order, as before.
+        const fresh = (scores === undefined
+            ? candidates
+            : candidates.toSorted((a, b) => (scores.get(b)?.score ?? -1) - (scores.get(a)?.score ?? -1))).slice(0, Math.max(0, Math.min(wanted, queueMax - current.items.length)));
         if (fresh.length === 0)
             return fail("every topic the LLM suggested was already made, queued or turned down for this schedule. Add more detail to the series brief under Edit, so it has new ground to cover.");
         const at = deps.clock.now().toISOString();
         const mode = current.topicGeneration.mode === "hold" ? "hold" : "queue";
+        if (scores !== undefined)
+            saveScores(deps.db, schedule.id, new Map(fresh.flatMap((title) => {
+                const score = scores.get(title);
+                return score === undefined ? [] : [[title, score]];
+            })), at);
         if (mode === "queue") {
+            const items = [...current.items, ...fresh.map((title) => ({ title, values: {} }))];
             deps.db
                 .prepare("UPDATE schedules SET items_json=?,version=version+1,updated_at=? WHERE id=? AND deleted_at IS NULL")
-                .run(JSON.stringify([...current.items, ...fresh.map((title) => ({ title, values: {} }))]), at, schedule.id);
+                .run(JSON.stringify(scores === undefined ? items : rankedItems(deps.db, schedule.id, items)), at, schedule.id);
         }
         else {
             const start = nextRank(deps, schedule.id);
@@ -158,6 +176,8 @@ async function ask(deps, schedule, options) {
              VALUES (?,?,?,'held',?,?)`)
                     .run(deps.uuid(), schedule.id, title, start + index, at);
             });
+            if (scores !== undefined)
+                rankHeld(deps, schedule.id);
         }
         deps.db
             .prepare("UPDATE schedules SET topics_generated_at=?,topics_failed_at=NULL,topics_error=NULL WHERE id=?")
@@ -180,6 +200,17 @@ async function ask(deps, schedule, options) {
         return { ok: true, added: fresh.length, mode };
     });
 }
+// Held topics in score order: unscored ones first as they were, then the scored, best first.
+export function rankHeld(deps, scheduleId) {
+    const held = deps.db
+        .prepare("SELECT id,title FROM schedule_topics WHERE schedule_id=? AND state='held' ORDER BY rank,created_at,id")
+        .all(scheduleId)
+        .map((row) => z.object({ id: z.string(), title: z.string() }).parse(row));
+    const rank = deps.db.prepare("UPDATE schedule_topics SET rank=? WHERE id=?");
+    rankedItems(deps.db, scheduleId, held).forEach((topic, index) => {
+        rank.run(index, topic.id);
+    });
+}
 function nextRank(deps, scheduleId) {
     const row = deps.db
         .prepare("SELECT max(rank) AS rank FROM schedule_topics WHERE schedule_id=? AND state='held'")
@@ -200,7 +231,8 @@ export function knownTitles(deps, scheduleId) {
     const channel = scheduleChannel(deps.db, scheduleId);
     const channels = projectChannels(deps.db);
     const projects = deps.db
-        .prepare(`SELECT id,title FROM projects WHERE ${liveProject()} ORDER BY created_at DESC`)
+        // A template's studio sample is no video of the channel's.
+        .prepare(`SELECT id,title FROM projects WHERE ${liveProject()} AND ${notTemplateSample()} ORDER BY created_at DESC`)
         .all()
         .map((row) => z.object({ id: z.string(), title: z.string() }).parse(row))
         .filter((row) => channel === undefined || (channels.get(row.id) ?? defaultChannelId) === channel.id)
@@ -254,20 +286,8 @@ export function topicMessages(schedule, templateTitle, known, count) {
 }
 // A JSON array of strings, or failing that one topic per line with bullets and numbers dropped.
 export function parseTopics(answer) {
-    const start = answer.indexOf("[");
-    const end = answer.lastIndexOf("]");
-    let lines;
-    if (start !== -1 && end > start) {
-        try {
-            const parsed = JSON.parse(answer.slice(start, end + 1));
-            if (Array.isArray(parsed))
-                lines = parsed;
-        }
-        catch {
-            lines = undefined;
-        }
-    }
-    lines ??= answer.split(/\r?\n/);
+    const parsed = jsonBetween(answer, "[", "]");
+    const lines = Array.isArray(parsed) ? parsed : answer.split(/\r?\n/);
     return lines
         .map((line) => typeof line === "string"
         ? line
@@ -286,16 +306,7 @@ export function parseTopics(answer) {
 export const heldValuesKey = "schedules.held-topic-values";
 const heldValuesSchema = z.record(z.string(), z.record(z.string(), z.string()));
 function readHeldValues(db) {
-    const raw = readSetting(db, heldValuesKey);
-    if (raw === undefined)
-        return {};
-    try {
-        const parsed = heldValuesSchema.safeParse(JSON.parse(raw));
-        return parsed.success ? parsed.data : {};
-    }
-    catch {
-        return {};
-    }
+    return readJsonSetting(db, heldValuesKey, heldValuesSchema, {});
 }
 // Entries of topics that are no longer held (approved, turned down, or gone with their
 // schedule) are dropped on every write.
@@ -394,11 +405,11 @@ export function editHeldTopic(deps, scheduleId, topicId, input) {
         const schedule = scheduleById(deps.db, scheduleId);
         if (schedule === undefined)
             return { ok: false, reason: "not-found" };
-        const template = deps.template(schedule.templateId);
-        if (template === undefined)
+        const known = scheduleKeywords(deps, schedule.templateId);
+        if (known === undefined)
             return { ok: false, reason: "missing-template" };
         const problems = topicRowProblems([{ title: parsed.data, values }], {
-            keywords: templateKeywords(template.document.form).filter((name) => name !== schedule.topicKeyword),
+            keywords: known.filter((name) => name !== schedule.topicKeyword),
             topicKeyword: schedule.topicKeyword,
         });
         if (problems.length > 0)
@@ -447,6 +458,7 @@ export function moveTopic(deps, scheduleId, input) {
             return { ok: false, reason: "invalid-input" };
         items.splice(Math.min(parsed.data.to, items.length), 0, topic);
         writeItems(deps, scheduleId, schedule.version, items);
+        pinTopic(deps.db, scheduleId, topic.title);
         return { ok: true, value: scheduleById(deps.db, scheduleId) };
     });
 }
@@ -463,11 +475,11 @@ export function replaceTopics(deps, scheduleId, input) {
         const schedule = open.value;
         if (schedule.version !== parsed.data.baseVersion)
             return { ok: false, reason: "conflict" };
-        const template = deps.template(schedule.templateId);
-        if (!template)
+        const keywords = scheduleKeywords(deps, schedule.templateId);
+        if (keywords === undefined)
             return { ok: false, reason: "missing-template" };
         const problems = topicRowProblems(parsed.data.items, {
-            keywords: templateKeywords(template.document.form),
+            keywords,
             topicKeyword: schedule.topicKeyword,
             kept: schedule.items,
         });

package/dist/slices/settings/cli-paths.js

@@ -2,9 +2,10 @@ import { constants } from "node:fs";
 import { access, stat } from "node:fs/promises";
 import { extname, isAbsolute } from "node:path";
 import { z } from "zod";
+import { isUnreachablePath } from "../../kernel/errors.js";
 import { cliProbeTimeoutMs, readinessFromProbe } from "./cli-status.js";
 import { providerById } from "./model.js";
-import { readSetting, writeSetting } from "./repo.js";
+import { readJsonSetting, writeSetting } from "./repo.js";
 export const cliPathMaxLength = 4096;
 const pathSchema = z
     .string()
@@ -20,8 +21,7 @@ export function cliPathStatus(db, id) {
     const provider = providerById(id);
     if (provider.auth !== "cli")
         throw new Error(`${id} is not a CLI provider`);
-    const stored = readSetting(db, `cli.path.${installationId(id)}`);
-    const configured = stored === undefined ? null : storedPathSchema.parse(JSON.parse(stored));
+    const configured = readJsonSetting(db, `cli.path.${installationId(id)}`, storedPathSchema, null);
     return { configured, command: configured ?? provider.binary };
 }
 // Read on each attempt, so a saved path reaches the next invocation without a restart.
@@ -82,9 +82,7 @@ async function save(deps, id, raw) {
                 : constants.X_OK);
         }
         catch (error) {
-            if (error instanceof Error &&
-                "code" in error &&
-                ["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"].includes(String(error.code)))
+            if (isUnreachablePath(error))
                 return {
                     ok: false,
                     message: "Slopify cannot find or run a program at this path. Check the path is correct and the file is allowed to run.",

package/dist/slices/settings/first-run.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { readinessIsUsable } from "../../kernel/ports/model.js";
-import { keyedProviders, readSetting, writeSetting } from "./repo.js";
+import { keyedProviders, readJsonSetting, readSetting, writeSetting } from "./repo.js";
 // What a fresh Play form picks before the user picks anything. Written once, on the first
 // launch that finds a command-line tool, and read by Play for every new draft.
 const choiceSchema = z.object({ provider: z.string().min(1), model: z.string() }).strict();
@@ -13,16 +13,7 @@ const doneKey = "first-run.done";
 // The order a text tool is preferred in when several are found.
 const textPreference = ["claude-code", "codex", "gemini"];
 export function readProviderDefaults(db) {
-    const raw = readSetting(db, defaultsKey);
-    if (raw === undefined)
-        return {};
-    try {
-        const parsed = providerDefaultsSchema.safeParse(JSON.parse(raw));
-        return parsed.success ? parsed.data : {};
-    }
-    catch {
-        return {};
-    }
+    return readJsonSetting(db, defaultsKey, providerDefaultsSchema, {});
 }
 export function dismissFirstRun(db) {
     writeSetting(db, doneKey, "1");

package/dist/slices/settings/model-reach.js

@@ -1,3 +1,4 @@
+import { probeRead } from "./probe-read.js";
 import { keyOf } from "./repo.js";
 // ceiling: a provider chosen in many templates still costs a handful of reads, not one per
 // model anywhere in the library.
@@ -12,23 +13,8 @@ export async function modelReach(deps, provider, models) {
         const known = reads.get(url);
         if (known !== undefined)
             return known;
-        const started = (async () => {
-            try {
-                const response = await deps.fetch(url, {
-                    headers: probe.headers(key),
-                    signal: AbortSignal.timeout(15_000),
-                    redirect: "error",
-                });
-                // A list is read whole; a single model's page only for its status.
-                const body = probe.model?.lists === undefined ? "" : await response.text();
-                if (probe.model?.lists === undefined)
-                    await response.body?.cancel().catch(() => { });
-                return { status: response.status, body };
-            }
-            catch {
-                return undefined;
-            }
-        })();
+        // A list is read whole; a single model's page only for its status.
+        const started = probeRead(deps.fetch, url, probe.headers(key), probe.model?.lists !== undefined);
         reads.set(url, started);
         return started;
     };

package/dist/slices/settings/model.js

@@ -37,6 +37,13 @@ export const systemVoiceProvider = "system-voice";
 export function isUncataloguedProvider(id) {
     return isLocalCliProvider(id) || id === systemVoiceProvider;
 }
+// The local stand-ins the bundled samples were made with (`src/sample-build/`): no catalogue
+// lists them, they cost nothing, and they exist only while the sample archives are built, so
+// a sample project names them but nothing new can run on them.
+export const sampleStandInProviders = ["sample-writer", "sample-artist", "sample-voice"];
+export function isSampleStandIn(id) {
+    return sampleStandInProviders.includes(id);
+}
 export const providers = [
     { id: "openrouter", family: "llm", displayName: "OpenRouter", auth: "key" },
     {
@@ -137,4 +144,7 @@ export const defaultSettings = {
     appearance: "system",
     loudness: defaultLoudness,
     subtitleModel: defaultEnglishSubtitleModel,
+    videoEncoder: "cpu",
+    clipEncodeSpeed: "thorough",
+    renderPriority: "background",
 };

package/dist/slices/settings/playback.js

@@ -2,17 +2,24 @@ import { z } from "zod";
 import { englishSubtitleModels } from "../../kernel/ports/subtitles.js";
 import { silenceGapSecondsMax } from "../admission/rules.js";
 import { loudnessFields } from "../loudness/model.js";
+import { clipEncodeSpeeds, renderPriorities, videoEncoders } from "../video/encoding.js";
 import { appearances, defaultSettings } from "./model.js";
-import { readSetting, writeSetting } from "./repo.js";
+import { readJsonSetting, writeSetting } from "./repo.js";
 // The `settings` table is key/value, so each setting is its own row and a value the app
 // does not understand costs only that one setting.
 const silenceGapKey = "silenceGapSeconds";
 const appearanceKey = "appearance";
 const loudnessKey = "loudness";
 const subtitleModelKey = "subtitleModel";
+const videoEncoderKey = "videoEncoder";
+const clipEncodeSpeedKey = "clipEncodeSpeed";
+const renderPriorityKey = "renderPriority";
 const silenceGapValue = z.number().int().min(0).max(silenceGapSecondsMax);
 const appearanceValue = z.enum(appearances);
 const subtitleModelValue = z.enum(englishSubtitleModels);
+const videoEncoderValue = z.enum(videoEncoders);
+const clipEncodeSpeedValue = z.enum(clipEncodeSpeeds);
+const renderPriorityValue = z.enum(renderPriorities);
 const loudnessValue = z.object({
     enabled: z.boolean(),
     videoLufs: z.number(),
@@ -24,6 +31,9 @@ export function readSettings(deps) {
         appearance: parsed(deps, appearanceKey, appearanceValue, defaultSettings.appearance),
         loudness: parsed(deps, loudnessKey, loudnessValue, defaultSettings.loudness),
         subtitleModel: parsed(deps, subtitleModelKey, subtitleModelValue, defaultSettings.subtitleModel),
+        videoEncoder: parsed(deps, videoEncoderKey, videoEncoderValue, defaultSettings.videoEncoder),
+        clipEncodeSpeed: parsed(deps, clipEncodeSpeedKey, clipEncodeSpeedValue, defaultSettings.clipEncodeSpeed),
+        renderPriority: parsed(deps, renderPriorityKey, renderPriorityValue, defaultSettings.renderPriority),
     };
 }
 export function saveSettings(deps, settings) {
@@ -49,6 +59,24 @@ export function saveSettings(deps, settings) {
             message: "Choose Most accurate, Balanced or Smallest in Settings → Production defaults → Subtitle timing model.",
         });
     }
+    if (!videoEncoderValue.safeParse(settings.videoEncoder).success) {
+        fields.push({
+            field: "videoEncoder",
+            message: "Choose Processor (x264) or NVIDIA graphics card (NVENC) in Settings → Production defaults → Video encoder.",
+        });
+    }
+    if (!clipEncodeSpeedValue.safeParse(settings.clipEncodeSpeed).success) {
+        fields.push({
+            field: "clipEncodeSpeed",
+            message: "Choose Thorough or Fast in Settings → Production defaults → Clip encoding.",
+        });
+    }
+    if (!renderPriorityValue.safeParse(settings.renderPriority).success) {
+        fields.push({
+            field: "renderPriority",
+            message: "Choose Normal or Background in Settings → Production defaults → Render priority.",
+        });
+    }
     if (fields.length > 0) {
         return { ok: false, fields };
     }
@@ -56,31 +84,14 @@ export function saveSettings(deps, settings) {
     writeSetting(deps.db, appearanceKey, JSON.stringify(settings.appearance));
     writeSetting(deps.db, loudnessKey, JSON.stringify(settings.loudness));
     writeSetting(deps.db, subtitleModelKey, JSON.stringify(settings.subtitleModel));
+    writeSetting(deps.db, videoEncoderKey, JSON.stringify(settings.videoEncoder));
+    writeSetting(deps.db, clipEncodeSpeedKey, JSON.stringify(settings.clipEncodeSpeed));
+    writeSetting(deps.db, renderPriorityKey, JSON.stringify(settings.renderPriority));
     return { ok: true, settings };
 }
 // A stored value is JSON, and a hand-edited database is the only way it can be anything
 // but what was saved. Such a row falls back to the default and says so in the log rather
 // than reaching the app or taking the settings page down.
 function parsed(deps, key, schema, fallback) {
-    const stored = readSetting(deps.db, key);
-    if (stored === undefined) {
-        return fallback;
-    }
-    const result = schema.safeParse(jsonOf(stored));
-    if (result.success) {
-        return result.data;
-    }
-    deps.log.write("warn", "settings.invalid", {
-        detail: `setting ${key} is not a value this build understands; using the default`,
-    });
-    return fallback;
-}
-function jsonOf(stored) {
-    try {
-        return JSON.parse(stored);
-    }
-    catch {
-        // Not JSON at all: the same answer as JSON of the wrong shape, decided by the caller.
-        return undefined;
-    }
+    return readJsonSetting(deps.db, key, schema, fallback, deps.log);
 }

package/dist/slices/settings/probe-read.js

@@ -0,0 +1,16 @@
+export async function probeRead(fetch, url, headers, withBody) {
+    try {
+        const response = await fetch(url, {
+            headers,
+            signal: AbortSignal.timeout(15_000),
+            redirect: "error",
+        });
+        const body = withBody ? await response.text() : "";
+        if (!withBody)
+            await response.body?.cancel().catch(() => { });
+        return { status: response.status, body };
+    }
+    catch {
+        return undefined;
+    }
+}

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/pick.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { jsonBetween } from "../../kernel/json-answer.js";
 import { youtubeTimestamp } from "../youtube/timestamps.js";
 import { shortHashtagsMax, shortHashtagsMin, shortTitleMax } from "./model.js";
 export const shortPickSchema = z.object({
@@ -128,7 +129,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,
@@ -226,17 +227,3 @@ export function noPicksMessage(problems, limits) {
 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,5 @@
 import { z } from "zod";
+import { jsonBetween } from "../../kernel/json-answer.js";
 export function imagePromptMessages(brief) {
     const plural = brief.count === 1 ? "prompt" : "prompts";
     return [
@@ -35,7 +36,7 @@ const fix = "Try again, or choose another model in Edit project → Providers.";
 // 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 +55,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

@@ -167,6 +167,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 +206,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",
+});