@gentbajko/slopify 2.3.1 → 2.5.0

package/dist/slices/revisions/mutation-prepare.js

@@ -5,7 +5,7 @@ import { normalizeArticleIntent } from "../rebuild/recipe-save.js";
 import { discardPreparedAssets } from "../storage/assets.js";
 import { prepareStagedFile, prepareText } from "../storage/prepare.js";
 import { outputSchema } from "../storage/schema.js";
-import { bindUpload, measureAudio, providedAssetSelected, } from "./mutation-assets.js";
+import { bindUpload, measureAudio, providedAssetSelected, providedOutput, providesOwnFile, } from "./mutation-assets.js";
 export async function prepareEditAssets(deps, base, edit) {
     const prepared = [];
     const allocated = [];
@@ -16,8 +16,8 @@ export async function prepareEditAssets(deps, base, edit) {
             const to = upload.destination;
             const role = to.kind === "image"
                 ? "image"
-                : to.kind === "provided" && to.stage === "thumbnail"
-                    ? "thumbnail"
+                : to.kind === "provided" && to.stage !== "audio"
+                    ? providedOutput[to.stage].role
                     : "audio_body";
             const result = prepareStagedFile(deps, {
                 projectId,
@@ -27,22 +27,22 @@ export async function prepareEditAssets(deps, base, edit) {
             });
             if (!result.ok)
                 throw new Error("A validated upload became unavailable.");
+            // The shorts' music is an asset the revision names, like a narration replacement,
+            // never an output of its own.
             const workKey = to.kind === "image"
                 ? `image:${to.imageKey}`
                 : to.kind === "narration"
                     ? to.key
-                    : to.stage === "audio"
-                        ? "audio:provided"
-                        : "thumbnail:image";
+                    : to.kind === "shortsMusic"
+                        ? "shorts:music"
+                        : providedOutput[to.stage].workKey;
             const item = {
                 ...result,
                 upload,
                 workKey,
-                slot: to.kind === "image"
+                slot: to.kind === "image" || to.kind === "narration" || to.kind === "shortsMusic"
                     ? workKey
-                    : to.kind === "narration"
-                        ? workKey
-                        : `${result.output.stageKind}:${role}`,
+                    : `${result.output.stageKind}:${role}`,
             };
             allocated.push(result.asset);
             const durationMs = result.output.stageKind === "audio"
@@ -91,21 +91,21 @@ export async function prepareEditAssets(deps, base, edit) {
                 slot: workKey,
             });
         }
-        for (const kind of ["audio", "thumbnail"]) {
+        for (const kind of ["audio", "thumbnail", "reference"]) {
             const assetId = content.provided[kind];
-            if (edit.config.sources[kind] !== "provide" ||
+            if (!providesOwnFile(edit.config, kind) ||
                 assetId === undefined ||
                 providedAssetSelected(base, kind, assetId) ||
                 prepared.some((row) => row.asset.id === assetId))
                 continue;
             const existing = deps.db
                 .prepare("SELECT descriptor FROM revision_outputs WHERE project_id=? AND asset_id=? AND json_extract(descriptor,'$.stageKind')=? LIMIT 1")
-                .get(projectId, assetId, kind);
+                .get(projectId, assetId, kind === "reference" ? "images" : kind);
             if (existing === undefined)
                 throw new Error("Validated replacement asset has no descriptor.");
             const descriptor = outputSchema.parse(JSON.parse(z.string().parse(existing.descriptor)));
             const asset = retainedAsset(deps, projectId, assetId);
-            const role = kind === "audio" ? "audio_body" : "thumbnail";
+            const role = providedOutput[kind].role;
             const item = {
                 asset,
                 output: {

package/dist/slices/revisions/mutations.js

@@ -78,7 +78,8 @@ export async function saveRevision(deps, input) {
                 ...supplied,
                 content: { ...supplied.content, regenerationTokens: tokens },
             });
-            const outputAssets = prepared.filter((row) => row.upload?.destination.kind !== "narration");
+            const outputAssets = prepared.filter((row) => row.upload?.destination.kind !== "narration" &&
+                row.upload?.destination.kind !== "shortsMusic");
             const inspected = measuredOutputs(deps, fresh, durations);
             const preparedManifest = {
                 outputs: [

package/dist/slices/revisions/publish.js

@@ -3,8 +3,12 @@ import { publicationTargets } from "../rebuild/repo.js";
 import { discardPreparedAssets } from "../storage/assets.js";
 import { positionedOutput, positionedPiece, projectSelected } from "./projection.js";
 import { isPublicationReplay, publicationAuthority, replacementSlots, validateBundle, validatePublication, } from "./publication-rules.js";
-import { insertAsset, insertManifestOutput, insertManifestPiece, outputsForRevision, revisionById, selectOutputRecord, selectPieceRecord, } from "./repo.js";
-export function commitRevisionOutputs(deps, publication, outputs, pieces) {
+import { insertAsset, insertManifestOutput, insertManifestPiece, outputsForRevision, piecesForRevision, revisionById, selectOutputRecord, selectPieceRecord, } from "./repo.js";
+export function commitRevisionOutputs(deps, publication, outputs, pieces, 
+// Output slots and piece keys this result makes obsolete, deselected in every revision
+// it lands in: the shorts past a pick's new count, a short's images past its new number.
+// Their files stay in history and leave the project's current outputs.
+retired) {
     const assets = [
         ...outputs.map((row) => row.asset),
         ...pieces.flatMap((row) => (row.asset === null ? [] : [row.asset])),
@@ -70,6 +74,20 @@ export function commitRevisionOutputs(deps, publication, outputs, pieces) {
                             .prepare("UPDATE revision_outputs SET selected=0 WHERE revision_id=? AND slot=?")
                             .run(revision.id, slot);
                     }
+                if (selected && retired !== undefined) {
+                    for (const slot of new Set(before.filter((row) => row.selected).map((row) => row.slot)))
+                        if (retired(slot))
+                            deps.db
+                                .prepare("UPDATE revision_outputs SET selected=0 WHERE revision_id=? AND slot=?")
+                                .run(revision.id, slot);
+                    for (const key of new Set(piecesForRevision(deps.db, revision.projectId, revision.id)
+                        .filter((row) => row.selected)
+                        .map((row) => row.key)))
+                        if (retired(key))
+                            deps.db
+                                .prepare("UPDATE revision_pieces SET selected=0 WHERE revision_id=? AND piece_key=?")
+                                .run(revision.id, key);
+                }
                 for (const output of outputs) {
                     const row = {
                         slot: output.slot,

package/dist/slices/revisions/schema.js

@@ -32,6 +32,7 @@ export const revisionContentSchema = z
         article: id.optional(),
         audio: id.optional(),
         thumbnail: id.optional(),
+        reference: id.optional(),
     })
         .strict(),
     imageOrder: z.array(id).max(60),
@@ -68,6 +69,16 @@ export const revisionContentSchema = z
         .optional(),
     regenerationTokens: tokens,
     promptTemplates: z.record(z.string().min(1), z.string().max(500000).nullable()),
+    shortsMusic: id.optional(),
+    shortsRanges: z
+        .record(z.string().regex(/^[1-9]\d?$/u), z
+        .object({
+        first: z.number().int().positive(),
+        last: z.number().int().positive(),
+        pick: z.string().min(1).max(128),
+    })
+        .strict())
+        .optional(),
 })
     .strict();
 export const revisionEditSchema = z
@@ -81,10 +92,14 @@ export const revisionEditSchema = z
         stagedFileId: id,
         destination: z.discriminatedUnion("kind", [
             z
-                .object({ kind: z.literal("provided"), stage: z.enum(["audio", "thumbnail"]) })
+                .object({
+                kind: z.literal("provided"),
+                stage: z.enum(["audio", "thumbnail", "reference"]),
+            })
                 .strict(),
             z.object({ kind: z.literal("image"), imageKey: id }).strict(),
             z.object({ kind: z.literal("narration"), key: workKey }).strict(),
+            z.object({ kind: z.literal("shortsMusic") }).strict(),
         ]),
     })
         .strict())

package/dist/slices/schedules/repo.js

@@ -308,7 +308,7 @@ function parseRun(row) {
 const internalRunError = "Slopify hit an internal error while starting this run. The next run will try again; if it keeps happening, use Download diagnostics in Settings and report it.";
 const runErrors = {
     "missing-template": "The template this schedule uses was deleted or changed. Edit the schedule and choose a template again.",
-    "unsupported-media": "This template uses audio, images or a thumbnail you supplied, which scheduled runs cannot use. Pick a template that generates these instead.",
+    "unsupported-media": "This template uses audio, images, a thumbnail or shorts background music you supplied, which scheduled runs cannot use. Pick a template that generates these instead, or remove the music under Outputs → Export → More shorts options on Play and save the template again.",
     "spend-limit": "Not started: the estimated cost was above this schedule's spend limit, or some prices were unknown. Raise the spend limit or choose models with known prices.",
     readiness: "Not started: a provider was not ready, for example a missing API key, model or voice. Check Settings → Providers; the next run will try again.",
     "not-found": "The template's settings are no longer valid, for example a prompt or voice it uses was deleted. Fix the template in Library > Templates and save it.",

package/dist/slices/schedules/service.js

@@ -152,7 +152,12 @@ function checkTemplate(deps, id, version) {
         return { ok: false, reason: "missing-template" };
     const sources = template.document.form.sources;
     const mediaSources = ["audio", "images", "thumbnail"];
-    if (mediaSources.some((kind) => sources[kind] === "provide"))
+    const { form } = template.document;
+    // A supplied file is attached again on Play, which a scheduled run cannot do; the shorts'
+    // background music is one too.
+    if (mediaSources.some((kind) => sources[kind] === "provide") ||
+        (form.shorts?.enabled === true && form.provided.shortsMusic) ||
+        (sources.images === "generate" && form.reference?.source === "provide"))
         return { ok: false, reason: "unsupported-media" };
     return { ok: true, value: true };
 }

package/dist/slices/settings/model.js

@@ -22,6 +22,11 @@ export const providerIds = [
 export function isLocalCliProvider(id) {
     return id === "claude-code" || id === "codex" || id === "gemini" || id === "codex-image";
 }
+// How many calls to a command-line tool run at once. Each Codex image is its own job - its
+// own folder and thread - so four are drawn side by side; the text CLIs keep three.
+export function localCliConcurrency(id) {
+    return id === "codex-image" ? 4 : 3;
+}
 export const providers = [
     { id: "openrouter", family: "llm", displayName: "OpenRouter", auth: "key" },
     {

package/dist/slices/shorts/captions.js

@@ -0,0 +1,272 @@
+// The shorts' captions: big, centred a little below the middle of the 9:16 frame, two to
+// four words on screen at a time, and the word being spoken drawn in a strong colour. Built
+// as ASS so the render burns them in with the same `ass` filter and font folder the video's
+// captions use. Pure.
+// Groups break at a sentence end, after a comma once they hold two words, at a pause, and
+// at four words.
+const groupMost = 4;
+const groupPause = 0.6;
+// A word left alone joins a neighbour across a pause up to this long; across a longer one
+// the neighbour would hang on screen through the silence.
+const joinPause = 1.5;
+// A group stays on screen this long after its last word, unless the next one starts first,
+// so a short pause doesn't flash an empty frame.
+const holdSeconds = 0.5;
+// ceiling: 7.5% of the height is about 144 px on 1080×1920, which fits twelve characters of
+// a typical sans-serif per line inside the side margins.
+const fontShare = 0.075;
+const lineCharacters = 12;
+const sideMargin = 80;
+// A little below the middle: clear of the face-height centre of most images, and clear of
+// the title and buttons the apps draw along the bottom.
+const heightShare = 0.62;
+// ASS colours are &HAABBGGRR. White for the words around it, gold for the one being spoken.
+const white = "&H00FFFFFF";
+const spoken = "&H0000D4FF";
+// ceiling: the title headline starts at 6% of the height (115 px) and shrinks to 3.5% until
+// it fits two lines. Barlow Bold averages about a third of its size per letter; 0.45 leaves
+// room for wider fonts a project may caption in.
+const titleShares = [0.06, 0.055, 0.05, 0.045, 0.04, 0.035];
+const letterWidth = 0.45;
+// Below the status bar, search and camera buttons the apps draw along the top: 11% of the
+// height is 211 px on 1920.
+const titleTop = 0.11;
+// The word times of a clip played `speed` times faster: every time divided, so the captions
+// stay on the words as they are heard.
+export function fasterWords(words, speed) {
+    if (speed === 1)
+        return words;
+    return words.map((word) => ({
+        ...word,
+        start: millis(word.start / speed),
+        end: millis(word.end / speed),
+    }));
+}
+// The words said inside the clip, with their times moved to the clip's own timeline and
+// clamped to it. A word is kept when most of it falls inside the clip.
+export function clipWords(words, start, end) {
+    const length = end - start;
+    return words
+        .filter((word) => (word.start + word.end) / 2 >= start && (word.start + word.end) / 2 <= end)
+        .map((word) => ({
+        text: word.text.replace(/\s+/g, " ").trim(),
+        start: millis(clamp(word.start - start, 0, length)),
+        end: millis(clamp(word.end - start, 0, length)),
+    }))
+        .filter((word) => word.text !== "" && word.end > word.start);
+}
+export function captionGroups(words) {
+    const groups = [];
+    let current = [];
+    const close = () => {
+        if (current.length > 0)
+            groups.push(current);
+        current = [];
+    };
+    for (const word of words) {
+        const previous = current.at(-1);
+        if (previous !== undefined && word.start - previous.end > groupPause)
+            close();
+        current.push(word);
+        if (current.length >= groupMost ||
+            sentenceEnd(word.text) ||
+            (current.length >= 2 && /[,;:]["'’”)]*$/.test(word.text)))
+            close();
+    }
+    close();
+    // Every change leaves one word fewer on its own, so this ends.
+    let changed = true;
+    while (changed) {
+        changed = groups.some((group, at) => group.length === 1 && keepCompany(groups, at));
+        for (let at = groups.length - 1; at >= 0; at--)
+            if (groups[at]?.length === 0)
+                groups.splice(at, 1);
+    }
+    return groups;
+}
+// A word left on its own would flash by alone, so it joins a neighbouring group: the one
+// before it, or, when it opens a sentence, the one after it first. When the neighbour is
+// too wide to take it, the neighbour's nearest word comes over to make a pair instead,
+// as long as that leaves the neighbour two words. It stays alone only after a long
+// silence, or between neighbours of one or two words that cannot fit it. Returns whether
+// the groups changed.
+function keepCompany(groups, at) {
+    const lone = groups[at];
+    const word = lone?.[0];
+    if (lone === undefined || word === undefined)
+        return false;
+    const before = groups[at - 1];
+    const after = groups[at + 1];
+    const opensSentence = before?.at(-1) !== undefined && sentenceEnd(before.at(-1)?.text ?? "");
+    // Words either side of a long silence stay apart: joined, one would sit on screen through it.
+    const near = (left, right) => left !== undefined && right !== undefined && right.start - left.end <= joinPause;
+    const tries = [
+        () => {
+            if (before === undefined || !near(before.at(-1), word))
+                return false;
+            if (!fits([...before, word], before))
+                return false;
+            before.push(word);
+            lone.length = 0;
+            return true;
+        },
+        () => {
+            if (after === undefined || !near(word, after[0]))
+                return false;
+            if (!fits([word, ...after], after))
+                return false;
+            after.unshift(word);
+            lone.length = 0;
+            return true;
+        },
+        () => {
+            const moved = before?.at(-1);
+            if (before === undefined || before.length < 3 || !near(moved, word))
+                return false;
+            before.pop();
+            if (moved !== undefined)
+                lone.unshift(moved);
+            return true;
+        },
+        () => {
+            const moved = after?.[0];
+            if (after === undefined || after.length < 3 || !near(word, moved))
+                return false;
+            after.shift();
+            if (moved !== undefined)
+                lone.push(moved);
+            return true;
+        },
+    ];
+    const order = opensSentence ? [1, 3, 0, 2] : [0, 2, 1, 3];
+    return order.some((index) => tries[index]?.() === true);
+}
+// A group with one more word fits when it holds at most one word over the usual most and
+// its longest line is no wider than a line holds, or than the group's own longest already
+// was.
+function fits(merged, group) {
+    const widest = (words) => longestLine(words.map((one) => one.text));
+    return (merged.length <= groupMost + 1 && widest(merged) <= Math.max(lineCharacters, widest(group)));
+}
+function sentenceEnd(text) {
+    return /[.!?]["'’”)]*$/.test(text);
+}
+export function shortCaptionsAss(words, style) {
+    const name = style.fontName.replace(/[\p{Cc},]/gu, " ").trim();
+    const size = Math.round(style.height * fontShare);
+    const position = `{\\an5\\pos(${String(style.width / 2)},${String(Math.round(style.height * heightShare))})}`;
+    const title = style.title === undefined || style.title.text.trim() === ""
+        ? undefined
+        : { ...titleLayout(style.title.text, style), seconds: style.title.seconds };
+    const header = `[Script Info]\nScriptType: v4.00+\nPlayResX: ${String(style.width)}\nPlayResY: ${String(style.height)}\nWrapStyle: 2\nScaledBorderAndShadow: yes\n\n[V4+ Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\nStyle: Short,${name},${String(size)},${white},${white},&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,7,3,5,${String(sideMargin)},${String(sideMargin)},0,1\n${title === undefined ? "" : `Style: Title,${name},${String(title.size)},${white},${white},&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,6,3,8,${String(sideMargin)},${String(sideMargin)},0,1\n`}\n[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n`;
+    const groups = captionGroups(words);
+    // The headline sits on a layer of its own, so a caption never hides it.
+    const events = title === undefined
+        ? []
+        : [
+            `Dialogue: 1,${assStamp(0)},${assStamp(title.seconds)},Title,,0,0,0,,{\\an8\\pos(${String(style.width / 2)},${String(Math.round(style.height * titleTop))})}${title.lines.map(assText).join("\\N")}\n`,
+        ];
+    for (const [at, group] of groups.entries()) {
+        const next = groups[at + 1]?.[0];
+        const last = group.at(-1);
+        if (last === undefined)
+            continue;
+        const shown = next === undefined ? last.end + holdSeconds : Math.min(last.end + holdSeconds, next.start);
+        const lines = lineBreaks(group.map((word) => word.text));
+        for (const [index, word] of group.entries()) {
+            const from = word.start;
+            const to = group[index + 1]?.start ?? Math.max(shown, word.end);
+            if (to <= from)
+                continue;
+            const text = group
+                .map((one, place) => {
+                const escaped = assText(one.text);
+                const shownWord = place === index
+                    ? `{\\c${spoken}&\\fscx108\\fscy108}${escaped}{\\c${white}&\\fscx100\\fscy100}`
+                    : escaped;
+                return `${shownWord}${lines.has(place) ? "\\N" : place < group.length - 1 ? " " : ""}`;
+            })
+                .join("");
+            events.push(`Dialogue: 0,${assStamp(from)},${assStamp(to)},Short,,0,0,0,,${position}${text}\n`);
+        }
+    }
+    return header + events.join("");
+}
+// The places after which a group breaks onto a second line: none when it fits on one,
+// otherwise the one break that makes the longer line shortest.
+function lineBreaks(texts, fit = lineCharacters) {
+    const total = texts.join(" ").length;
+    if (total <= fit || texts.length < 2)
+        return new Set();
+    let best = 0;
+    let bestLongest = Number.POSITIVE_INFINITY;
+    for (let after = 0; after < texts.length - 1; after++) {
+        const top = texts.slice(0, after + 1).join(" ").length;
+        const bottom = texts.slice(after + 1).join(" ").length;
+        const longest = Math.max(top, bottom);
+        if (longest < bestLongest) {
+            bestLongest = longest;
+            best = after;
+        }
+    }
+    return new Set([best]);
+}
+// The characters of the longest line the words are drawn on.
+function longestLine(texts) {
+    return Math.max(...splitAt(texts, lineBreaks(texts)).map((line) => line.length));
+}
+// The title headline: the largest size at which it fits two lines inside the side margins,
+// broken where the longer line is shortest; at the smallest size a title still too long is
+// cut at a word and ends in an ellipsis.
+export function titleLayout(title, style) {
+    const words = title
+        .replace(/\s+/g, " ")
+        .trim()
+        .split(" ")
+        .filter((word) => word !== "");
+    const room = (share) => Math.floor((style.width - 2 * sideMargin) / (style.height * share * letterWidth));
+    const laid = (share, texts) => {
+        const fit = room(share);
+        const breaks = lineBreaks(texts, fit);
+        const lines = breaks.size === 0 ? [texts.join(" ")] : splitAt(texts, breaks);
+        return { size: Math.round(style.height * share), lines, fit };
+    };
+    for (const share of titleShares) {
+        const layout = laid(share, words);
+        if (layout.lines.every((line) => line.length <= layout.fit))
+            return { size: layout.size, lines: layout.lines };
+    }
+    const smallest = titleShares.at(-1) ?? 0.03;
+    const fit = room(smallest);
+    const kept = [];
+    for (const word of words) {
+        if ([...kept, word].join(" ").length + 1 > fit * 2 - 1)
+            break;
+        kept.push(word);
+    }
+    const layout = laid(smallest, [...kept.slice(0, -1), `${kept.at(-1) ?? ""}…`]);
+    return { size: layout.size, lines: layout.lines };
+}
+function splitAt(texts, breaks) {
+    const lines = [[]];
+    for (const [at, text] of texts.entries()) {
+        lines.at(-1)?.push(text);
+        if (breaks.has(at))
+            lines.push([]);
+    }
+    return lines.map((line) => line.join(" "));
+}
+function assText(text) {
+    // Full-width alternatives stay visible and cannot open an ASS override or escape.
+    return text.replaceAll("\\", "＼").replaceAll("{", "｛").replaceAll("}", "｝");
+}
+function assStamp(seconds) {
+    const cs = Math.max(0, Math.round(seconds * 100));
+    return `${String(Math.floor(cs / 360_000))}:${String(Math.floor(cs / 6000) % 60).padStart(2, "0")}:${String(Math.floor(cs / 100) % 60).padStart(2, "0")}.${String(cs % 100).padStart(2, "0")}`;
+}
+function millis(seconds) {
+    return Math.round(seconds * 1000) / 1000;
+}
+function clamp(value, low, high) {
+    return Math.min(high, Math.max(low, value));
+}

package/dist/slices/shorts/clips.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { clipBounds, shortPickSchema } from "./pick.js";
+// What the pick saves in its payload. `sentences` (the numbered transcript's times and
+// words) came with hand-set ranges; a pick saved before them has none, and its clips can
+// only be adjusted after the moments are picked again.
+export const pickedShortsSchema = z.object({
+    shorts: z.array(shortPickSchema),
+    durationSeconds: z.number().finite().nonnegative().optional(),
+    sentences: z
+        .array(z.object({
+        start: z.number().finite().nonnegative(),
+        end: z.number().finite().nonnegative(),
+        text: z.string(),
+    }))
+        .optional(),
+});
+export function pickedShortsOf(payload) {
+    if (payload === null || payload === undefined)
+        return undefined;
+    try {
+        const parsed = pickedShortsSchema.safeParse(JSON.parse(payload));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Why a hand-set range can't be used, in the words Edit project shows under the clip; or
+// undefined when it can.
+export function rangeProblem(picked, number, first, last, limits, others = []) {
+    const sentences = picked.sentences;
+    if (sentences === undefined || sentences.length === 0)
+        return "These shorts were picked before clips could be adjusted by hand. Use Pick different moments, then adjust the new clips.";
+    if (!picked.shorts.some((clip) => clip.number === number))
+        return `There is no short ${String(number)} any more. Reload the page and choose again.`;
+    if (!Number.isInteger(first) ||
+        !Number.isInteger(last) ||
+        first < 1 ||
+        last > sentences.length ||
+        first > last)
+        return `Choose a start sentence that comes before the end sentence, between 1 and ${String(sentences.length)}.`;
+    const bounds = clipBounds(sentences, first, last, durationOf(picked));
+    if (bounds === undefined)
+        return "Choose a start and an end sentence from the transcript.";
+    const seconds = bounds.end - bounds.start;
+    // The same hundredth-of-a-second allowance the pick is checked with.
+    if (seconds < limits.minSeconds - 0.01)
+        return `Short ${String(number)} would last ${String(Math.round(seconds))} seconds, shorter than the ${String(limits.minSeconds)}-second minimum. Start it earlier or end it later.`;
+    if (seconds > limits.maxSeconds + 0.01)
+        return `Short ${String(number)} would last ${String(Math.round(seconds))} seconds, longer than the ${String(limits.maxSeconds)}-second maximum. Start it later or end it earlier.`;
+    const clash = others.find((clip) => clip.number !== number && first <= clip.last && last >= clip.first);
+    if (clash !== undefined)
+        return `Short ${String(number)} would share sentences with short ${String(clash.number)} (sentences ${String(clash.first)}-${String(clash.last)}). Choose a range that doesn't overlap it.`;
+    return undefined;
+}
+// The picked clips with every usable hand-set range in place: the model's title,
+// description and hashtags stay, the sentences, times and words are the range's. A range
+// set against another pick, or one that no longer fits the limits, is left out.
+export function effectiveClips(picked, ranges, pick, limits) {
+    const sentences = picked.sentences;
+    if (ranges === undefined || sentences === undefined)
+        return picked.shorts;
+    const clips = [...picked.shorts];
+    for (const [at, clip] of clips.entries()) {
+        const range = ranges[String(clip.number)];
+        if (range === undefined || range.pick !== pick)
+            continue;
+        if (rangeProblem(picked, clip.number, range.first, range.last, limits, clips) !== undefined)
+            continue;
+        const bounds = clipBounds(sentences, range.first, range.last, durationOf(picked));
+        if (bounds === undefined)
+            continue;
+        clips[at] = {
+            ...clip,
+            first: range.first,
+            last: range.last,
+            start: bounds.start,
+            end: bounds.end,
+            text: sentences
+                .slice(range.first - 1, range.last)
+                .map((sentence) => sentence.text)
+                .join(" "),
+        };
+    }
+    return clips;
+}
+function durationOf(picked) {
+    return picked.durationSeconds ?? picked.sentences?.at(-1)?.end ?? 0;
+}