@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/rebuild/runtime-image.js

@@ -1,10 +1,12 @@
 import { readFileSync } from "node:fs";
 import { z } from "zod";
+import { imageBlob } from "../channels/repo.js";
 import { outputPath } from "../storage/layout.js";
 // The provider call an image step makes: its request, the effort when one is chosen and, while
 // the project's Establishing image is on, that image's bytes as the visual reference.
 export function imageCall(deps, projectId, input, previewLabel) {
     const reference = referenceImage(deps, projectId, input);
+    const cast = castImages(deps, input);
     return {
         provider: input.provider,
         model: input.model,
@@ -12,6 +14,7 @@ export function imageCall(deps, projectId, input, previewLabel) {
         aspect: input.aspect,
         ...(input.thinking === undefined ? {} : { thinking: input.thinking }),
         ...(reference === undefined ? {} : { reference }),
+        ...(cast === undefined ? {} : { cast }),
         ...(previewLabel === undefined ? {} : { previewLabel }),
     };
 }
@@ -19,7 +22,7 @@ function referenceImage(deps, projectId, input) {
     if (input.reference === undefined)
         return undefined;
     // The step waits for the establishing image, so a missing one went away since.
-    const missing = "The establishing image this image is drawn from is missing. Use Regenerate on the establishing image in the Images section (or upload it again in Edit project → Images), then use Retry stage.";
+    const missing = "The establishing image this image is drawn from is missing. Use Regenerate on the establishing image in the Images section (or upload it again in Edit project → Images), then use Try again.";
     if (input.reference.assetId === null)
         throw new Error(missing);
     const row = z
@@ -39,9 +42,25 @@ function referenceImage(deps, projectId, input) {
     }
     const mime = imageMime(bytes);
     if (mime === undefined)
-        throw new Error("The establishing image is not a PNG or JPEG file, so it can't be sent as a reference. Upload a PNG or JPEG in Edit project → Images → Establishing image, then use Retry stage.");
+        throw new Error("The establishing image is not a PNG or JPEG file, so it can't be sent as a reference. Upload a PNG or JPEG in Edit project → Images → Establishing image, then use Try again.");
     return { bytes, mime };
 }
+// The cast pictures the request names, read by hash from the database. They are never removed
+// while a project may name them, so a missing one came from a backup of another install.
+function castImages(deps, input) {
+    if (input.cast === undefined)
+        return undefined;
+    return input.cast.map((member) => ({
+        name: member.name,
+        description: member.description,
+        images: member.images.map((sha256) => {
+            const blob = imageBlob(deps.db, sha256);
+            if (blob === undefined)
+                throw new Error(`A picture of ${member.name} that this project was started with is not in this Slopify's database, so it can't be sent as a reference. Add the picture again in Channels → Cast, then start the video again from Play.`);
+            return blob;
+        }),
+    }));
+}
 function imageMime(bytes) {
     const png = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
     if (png.every((value, index) => bytes[index] === value))

package/dist/slices/rebuild/runtime-local.js

@@ -1,12 +1,18 @@
-import { statSync } from "node:fs";
+import { rmSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { z } from "zod";
 import { referenceKey } from "../admission/model.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
+import { levelPieces } from "../loudness/level-pieces.js";
 import { joinNarration } from "../narration/concat.js";
+import { applyPauses, planPieces } from "../narration/pauses.js";
 import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
 import { outputPath } from "../storage/layout.js";
+import { probeDurationMs, runFfmpeg } from "../video/ffmpeg.js";
+import { turnJoinArgs } from "../voices/join.js";
+import { levelOperation } from "./recipe-loudness.js";
+import { executeFigureCard } from "./runtime-figure-card.js";
 import { publishNarrationText } from "./runtime-narration-text.js";
 import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
 import { preparedResult, preparedText, preparedTexts, publishResult, } from "./runtime-publication.js";
@@ -20,7 +26,7 @@ export async function executeLocalRecipe(deps, context, piece) {
     const input = piece.input;
     if (input.kind === "provided") {
         if (input.assetId === null)
-            throw new Error("A file you uploaded for this project is missing. Upload it again in Edit project, then Retry stage.");
+            throw new Error("A file you uploaded for this project is missing. Upload it again in Edit project, then Try again.");
         const row = z
             .object({ id: z.string(), project_id: z.string(), path: z.string(), created_at: z.string() })
             .parse(deps.db
@@ -46,12 +52,16 @@ export async function executeLocalRecipe(deps, context, piece) {
         return "done";
     }
     if (input.kind !== "local")
-        throw new Error("Slopify hit an internal error (a local step was set up wrongly). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (a local step was set up wrongly). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+    if (input.operation === "figure-card-v1")
+        return executeFigureCard(deps, context, piece);
     if (input.operation === "narration-files-v1") {
         await publishNarrationText(deps, context, piece);
         return "done";
     }
-    if (input.operation === "concat-narration") {
+    if (input.operation === "concat-narration" ||
+        input.operation === "concat-turns-v1" ||
+        input.operation === levelOperation) {
         await concatenate(deps, context, piece);
         return "done";
     }
@@ -78,19 +88,19 @@ export async function executeLocalRecipe(deps, context, piece) {
         });
         return "done";
     }
-    throw new Error(`Slopify hit an internal error (no handler for the step "${input.operation}"). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
+    throw new Error(`Slopify hit an internal error (no handler for the step "${input.operation}"). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
 }
 async function concatenate(deps, context, piece) {
     const view = executionView(deps, context.work.projectId, context.work.revisionId);
     if (view === undefined)
-        throw new Error("Slopify hit an internal error (the project version being built is missing). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the project version being built is missing). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const row = deps.db
         .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
         .get(context.work.workId);
     const plan = executionPlan(deps, view, savedCatalogue(row?.recipe_context));
     const recipe = plan.recipes.find((candidate) => candidate.key === piece.key && candidate.fingerprint === piece.fingerprint);
     if (recipe === undefined)
-        throw new Error("Slopify hit an internal error (the narration chunks to join no longer match the project's saved inputs). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the narration chunks to join no longer match the project's saved inputs). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const files = recipe.dependsOn.map((key) => {
         const input = view.pieces.find((candidate) => candidate.key === key &&
             candidate.selected &&
@@ -98,36 +108,73 @@ async function concatenate(deps, context, piece) {
             candidate.piece.state === "done" &&
             candidate.fingerprint === plan.recipes.find((value) => value.key === key)?.fingerprint);
         if (input?.assetId === null || input === undefined)
-            throw new Error("One narration chunk has no saved audio, so the narration can't be joined together. Regenerate the missing chunk in Edit project → Narration, then Retry stage.");
+            throw new Error("One narration chunk has no saved audio, so the narration can't be joined together. Regenerate the missing chunk in Edit project → Narration, then Try again.");
         const asset = deps.db
             .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
             .get(input.assetId, context.work.projectId);
         return outputPath(deps.paths, context.work.projectId, z.string().parse(asset?.path));
     });
+    // Level the volume repeats the join its recipe names, from the same pieces, each levelled
+    // first (`recipe-loudness.ts`).
+    const level = recipe.input.kind === "local" && recipe.input.operation === levelOperation;
+    const [operation, values] = recipe.input.kind !== "local"
+        ? ["", undefined]
+        : level
+            ? z.tuple([z.string(), z.unknown(), z.unknown()]).parse(recipe.input.values)
+            : [recipe.input.operation, recipe.input.values];
     const pending = allocateAsset(deps, context.work.projectId, "narration.mp3");
+    const piecesDirectory = join(dirname(pending.absolutePath), "levelled");
     try {
-        const durationMs = await joinNarration({ bin: deps.ffmpeg, log: deps.log }, {
-            files,
-            output: pending.absolutePath,
-            listPath: join(dirname(pending.absolutePath), "parts.txt"),
-            signal: context.signal,
-        });
+        const run = { bin: deps.ffmpeg, log: deps.log, signal: context.signal };
+        const levelled = level ? await levelPieces(run, files, piecesDirectory) : undefined;
+        // Pauses between sentences: planned from the pieces as spoken, made in what is joined.
+        const pauses = pausesIn(values);
+        const paced = pauses === undefined
+            ? undefined
+            : await applyPauses(run, levelled?.files ?? files, paceScaled(await planPieces(run, files.map((file, at) => ({
+                file,
+                text: pieceText(plan.recipes.find((one) => one.key === recipe.dependsOn[at])),
+                next: pauses.next[at] ?? "end",
+            })), pauses.settings), operation === "concat-turns-v1" ? values : undefined), join(piecesDirectory, "paced"));
+        const joined = paced?.files ?? levelled?.files ?? files;
+        const durationMs = operation === "concat-turns-v1"
+            ? await joinTurns(run, joined, values, pending.absolutePath)
+            : await joinNarration({ bin: deps.ffmpeg, log: deps.log }, {
+                files: joined,
+                output: pending.absolutePath,
+                listPath: join(dirname(pending.absolutePath), "parts.txt"),
+                signal: context.signal,
+                reencode: level || paced !== undefined,
+            });
+        rmSync(piecesDirectory, { recursive: true, force: true });
         context.signal.throwIfAborted();
         const asset = sealAsset(deps, pending);
-        const role = piece.key === "audio:intro"
-            ? "audio_intro"
-            : piece.key === "audio:outro"
-                ? "audio_outro"
-                : "audio_body";
+        const segment = /^(?:audio|level):(intro|outro)$/.exec(piece.key)?.[1] ?? "body";
+        const role = level
+            ? "audio_levelled"
+            : piece.key === "audio:intro"
+                ? "audio_intro"
+                : piece.key === "audio:outro"
+                    ? "audio_outro"
+                    : "audio_body";
+        const voice = view.revision.config.audio === undefined
+            ? {}
+            : {
+                provider: view.revision.config.audio.provider,
+                model: view.revision.config.audio.model,
+                voice: view.revision.config.audio.voice,
+            };
         await publishResult(deps, context, piece, [
-            preparedResult(deps, context, piece, role, asset, durationMs, view.revision.config.audio === undefined
-                ? {}
+            preparedResult(deps, context, piece, role, asset, durationMs, levelled === undefined
+                ? voice
                 : {
-                    provider: view.revision.config.audio.provider,
-                    model: view.revision.config.audio.model,
-                    voice: view.revision.config.audio.voice,
+                    ...voice,
+                    segment: segment,
+                    loudness: levelled.report,
                 }),
         ], { durationMs }, asset);
+        if (level)
+            return;
         for (const key of recipe.dependsOn) {
             const retained = view.pieces.find((candidate) => candidate.key === key && candidate.selected && candidate.available);
             if (retained?.publicationId === null || retained === undefined)
@@ -140,6 +187,83 @@ async function concatenate(deps, context, piece) {
         }
     }
     finally {
+        rmSync(piecesDirectory, { recursive: true, force: true });
         discardPreparedAssets(deps, [pending]);
     }
 }
+// The pauses a join's values ask for (`recipe-pauses.ts`): its third value, when there is one.
+function pausesIn(values) {
+    const value = Array.isArray(values) ? values[2] : undefined;
+    const parsed = z
+        .tuple([
+        z.literal("pauses-v1"),
+        z.number(),
+        z.number(),
+        z.array(z.enum(["end", "turn", "sentence", "paragraph"])),
+    ])
+        .safeParse(value);
+    if (!parsed.success)
+        return undefined;
+    const [, sentenceSeconds, paragraphSeconds, next] = parsed.data;
+    return { settings: { sentenceSeconds, paragraphSeconds }, next };
+}
+// A speaker's pace plays their turn faster or slower, pauses included, so a turn's added
+// silence is scaled by it to come out at the minimum.
+function paceScaled(plans, turnValues) {
+    const layout = Array.isArray(turnValues) ? turnValues[1] : undefined;
+    if (!Array.isArray(layout))
+        return plans;
+    return plans.map((plan, at) => {
+        const pace = z.tuple([z.number().positive(), z.number()]).safeParse(layout[at]);
+        const factor = pace.success ? pace.data[0] : 1;
+        if (factor === 1)
+            return plan;
+        return {
+            ...plan,
+            padEnd: plan.padEnd * factor,
+            pauses: {
+                ...plan.pauses,
+                inserts: plan.pauses.inserts.map((one) => ({ ...one, seconds: one.seconds * factor })),
+            },
+        };
+    });
+}
+// The words a narration piece speaks, where its sentences end: the clean words of a request, or
+// of a piece supplied as a file.
+function pieceText(recipe) {
+    if (recipe === undefined)
+        return "";
+    const input = recipe.input;
+    // The words as said: a prepared request's delivery tags take no time of their own.
+    if (input.kind === "tts")
+        return (input.spokenText ?? input.text).replace(/\[[^\]]*\]/g, "");
+    if (input.kind === "provided" &&
+        Array.isArray(input.semantic) &&
+        typeof input.semantic[0] === "string")
+        return input.semantic[0];
+    return "";
+}
+// A multi-voice narration: every turn at its speaker's pace with the gap between turns, as the
+// recipe laid it out (`recipe-voices.ts`), measured off the file that was written. `values` is
+// the concat-turns-v1 recipe's own values.
+export async function joinTurns(run, files, values, output) {
+    const layout = z
+        .tuple([z.unknown(), z.array(z.tuple([z.number().positive(), z.number().nonnegative()]))])
+        // The pauses between sentences may follow (`recipe-pauses.ts`); they were made already.
+        .rest(z.unknown())
+        .parse(values)[1];
+    if (layout.length !== files.length || files.length === 0)
+        throw new Error("Slopify hit an internal error (the speaker turns to join don't match their audio). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+    await runFfmpeg({
+        bin: run.bin,
+        args: turnJoinArgs(files.map((path, index) => ({
+            path,
+            pace: layout[index]?.[0] ?? 1,
+            gapAfter: layout[index]?.[1] ?? 0,
+        })), output),
+        signal: run.signal,
+        log: run.log,
+        onProgress: () => { },
+    });
+    return probeDurationMs(run.bin, output, run.signal, run.log);
+}

package/dist/slices/rebuild/runtime-materialize.js

@@ -136,6 +136,10 @@ function futureKey(recipe) {
         return `narration:prepare:${recipe.input.preparation.segment}:future`;
     if (recipe.input.kind === "tts")
         return `audio:${recipe.input.segment}:future`;
+    // The descriptions unfold from the one step that stood in for them while the text was
+    // unwritten.
+    if (recipe.key.startsWith("narration:describe:") || recipe.key.startsWith("figure:card:"))
+        return "narration:describe:future";
     if (recipe.key.startsWith("research:chapter:"))
         return "research:planner";
     if (recipe.key === "article:continuation")
@@ -143,6 +147,10 @@ function futureKey(recipe) {
     // A short's images and render unfold from its image prompts, admitted with them: under the
     // pick on a first run, or on their own when one short is made again and the pick is kept.
     // The prompts unfold from the pick's answer.
+    // A short's review unfolds with the short it reviews.
+    const reviewed = /^review:(shorts:\d+)$/.exec(recipe.key);
+    if (reviewed?.[1] !== undefined)
+        return `${reviewed[1]}:prompts`;
     const clip = /^(shorts:\d+):(?:image:\d+|render)$/.exec(recipe.key);
     if (clip?.[1] !== undefined)
         return `${clip[1]}:prompts`;

package/dist/slices/rebuild/runtime-narration-reuse.js

@@ -3,7 +3,8 @@ import { insertManifestOutput, insertManifestPiece, selectOutputRecord, selectPi
 import { retainedNarrationPieces } from "./narration-history.js";
 import { matchingNarrationPiece } from "./narration-reuse.js";
 export function bindNarrationReuse(deps, view, recipe, ordinal) {
-    if (recipe.input.kind === "local" && recipe.input.operation === "concat-narration") {
+    if (recipe.input.kind === "local" &&
+        (recipe.input.operation === "concat-narration" || recipe.input.operation === "concat-turns-v1")) {
         const completed = view.pieces.find((one) => one.available &&
             one.piece.state === "done" &&
             one.key === recipe.key &&

package/dist/slices/rebuild/runtime-narration-text.js

@@ -9,7 +9,7 @@ export function joinedNarration(parts) {
 export function narrationTextParts(view, plan, segment) {
     const concat = plan.recipes.find((row) => row.key === (segment === "body" ? "audio:body:concat" : `audio:${segment}`));
     if (concat === undefined)
-        throw new Error(`Slopify hit an internal error (the ${segment} narration is missing from the project plan). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
+        throw new Error(`Slopify hit an internal error (the ${segment} narration is missing from the project plan). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
     return concat.dependsOn.map((key) => {
         const recipe = plan.recipes.find((row) => row.key === key);
         const selected = view.pieces.find((row) => row.key === key &&
@@ -18,7 +18,7 @@ export function narrationTextParts(view, plan, segment) {
             row.piece.state === "done" &&
             row.fingerprint === recipe?.fingerprint);
         if (selected === undefined || recipe === undefined)
-            throw new Error("Some narration chunks aren't finished, so the full narration text isn't available. Let the Narration stage finish (Resume, or Retry stage on it), or regenerate the missing chunk in Edit project → Narration.");
+            throw new Error("Some narration chunks aren't finished, so the full narration text isn't available. Let the Narration stage finish (Resume, or Try again on it), or regenerate the missing chunk in Edit project → Narration.");
         const input = recipe.input;
         if (input.kind === "provided" &&
             Array.isArray(input.semantic) &&
@@ -29,13 +29,13 @@ export function narrationTextParts(view, plan, segment) {
                 requestText: null,
             };
         if (input.kind !== "tts")
-            throw new Error("Slopify hit an internal error (a narration chunk's text was never worked out). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (a narration chunk's text was never worked out). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         const payload = z
             .object({ text: z.string().optional(), spokenText: z.string().optional() })
             .parse(JSON.parse(selected.piece.payload ?? "{}"));
         if (input.spokenText !== undefined &&
             (payload.spokenText !== input.spokenText || payload.text !== input.text))
-            throw new Error("A narration chunk's audio no longer matches its prepared text. Regenerate that chunk in Edit project → Narration, then Retry stage.");
+            throw new Error("A narration chunk's audio no longer matches its prepared text. Regenerate that chunk in Edit project → Narration, then Try again.");
         return {
             logicalKey: input.logicalKey,
             spokenText: input.spokenText === undefined ? (payload.text ?? input.text) : (payload.spokenText ?? ""),
@@ -45,7 +45,7 @@ export function narrationTextParts(view, plan, segment) {
 }
 export async function publishNarrationText(deps, context, piece) {
     if (piece.input.kind !== "local")
-        throw new Error("Slopify hit an internal error (the narration text file step was set up wrongly). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the narration text file step was set up wrongly). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const { segment } = z
         .object({ segment: z.enum(["body", "intro", "outro"]) })
         .parse(piece.input.values);
@@ -54,10 +54,10 @@ export async function publishNarrationText(deps, context, piece) {
         .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
         .get(context.work.workId);
     if (view === undefined)
-        throw new Error("Slopify hit an internal error (the project version being narrated is missing). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the project version being narrated is missing). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const plan = executionPlan(deps, view, savedCatalogue(row?.recipe_context));
     if (!plan.recipes.some((recipe) => recipe.key === piece.key && recipe.fingerprint === piece.fingerprint))
-        throw new Error("Slopify hit an internal error (the narration text no longer matches the project's saved inputs). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the narration text no longer matches the project's saved inputs). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const parts = narrationTextParts(view, plan, segment);
     const outputs = preparedTexts(deps, context, piece, [
         ["narration_txt", `${segment}-narration.txt`, joinedNarration(parts)],

package/dist/slices/rebuild/runtime-pictures.js

@@ -0,0 +1,28 @@
+import { existsSync } from "node:fs";
+import { basename } from "node:path";
+import { outputPath } from "../storage/layout.js";
+// The file behind a picture the article names (`![alt](maps/relief.png)`): an image uploaded
+// to the project under that file name. An article's pictures are otherwise web addresses
+// Slopify never fetches, so a figure without its upload is described and drawn from its
+// caption alone.
+export function articlePicture(deps, view, named) {
+    if (named === undefined)
+        return undefined;
+    const name = basename((named.split(/[?#]/)[0] ?? "").replace(/\\/g, "/")).toLowerCase();
+    if (name === "")
+        return undefined;
+    for (const image of Object.values(view.revision.content.imageDefinitions)) {
+        if (image.source !== "provide" || image.assetId === null)
+            continue;
+        const row = deps.db
+            .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
+            .get(image.assetId, view.revision.projectId);
+        const path = typeof row?.path === "string" ? row.path : undefined;
+        if (path === undefined || basename(path).toLowerCase() !== name)
+            continue;
+        const file = outputPath(deps.paths, view.revision.projectId, path);
+        if (existsSync(file))
+            return file;
+    }
+    return undefined;
+}

package/dist/slices/rebuild/runtime-piece-label.js

@@ -4,6 +4,9 @@ import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js"
 // Undefined for steps that name their own place (captions, export) or have no single one.
 export function pieceLabel(deps, context, piece) {
     const { key } = piece;
+    const variant = /^thumbnail:image:([23])$/.exec(key);
+    if (variant !== null)
+        return `Thumbnail ${variant[1] ?? ""}`;
     if (key === "thumbnail:image" || key.startsWith("thumbnail:"))
         return "Thumbnail";
     if (key === "reference:image")
@@ -14,6 +17,30 @@ export function pieceLabel(deps, context, piece) {
         return "Document";
     if (key === "youtube:description")
         return "YouTube description";
+    if (key.startsWith("review:")) {
+        const item = key.slice("review:".length);
+        const itemLabel = item === "narration"
+            ? "Narration"
+            : /^shorts:\d+$/.test(item)
+                ? `Short ${item.slice("shorts:".length)}`
+                : pieceLabel(deps, context, { key: item });
+        return `Review of ${itemLabel ?? "an item"}`;
+    }
+    if (key === "voices:files")
+        return "MP3 and M4B files";
+    if (key === "script:attribute")
+        return "Speaker split";
+    if (key === "narration:describe:future")
+        return "Narration descriptions";
+    const card = /^figure:card:(\d+)$/.exec(key);
+    if (card !== null)
+        return `On-screen card ${card[1] ?? ""}`;
+    const described = /^narration:describe:(\d+)$/.exec(key);
+    if (described !== null)
+        return `Narration description ${described[1] ?? ""}`;
+    const turn = /^audio:body:turn:(\d+):\d+$/.exec(key);
+    if (turn !== null)
+        return `Turn ${turn[1] ?? ""}`;
     if (key === "shorts:pick" || key === "shorts:future")
         return "Shorts";
     if (key === "animate:future")