videobook 0.0.0-stage → 0.2.0

package/dist/tools/render-settings.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { readLanguageCode, iso1FromIso3 } from "../jobs/_translate-transcript.js";
+import { readRenderSettings, RENDER_ORIENTATIONS } from "./reconcile-project-work.js";
+const TRANSLATED_SIDECAR_RE = /^elevenlabs\.([a-z]{2})\.json$/;
+async function readTranscriptInfo(engine, assetId) {
+    const info = { sourceLanguageCode: null, sourceLanguage: null, cachedTranslations: [] };
+    const manifestResult = await engine.files.manifest(assetId);
+    if (manifestResult.ok) {
+        for (const file of manifestResult.value.files) {
+            const match = TRANSLATED_SIDECAR_RE.exec(file.name);
+            if (match)
+                info.cachedTranslations.push(match[1]);
+        }
+    }
+    const transcriptResult = await engine.files.read(assetId, "elevenlabs.json");
+    if (transcriptResult.ok) {
+        try {
+            const raw = JSON.parse(transcriptResult.value.toString());
+            info.sourceLanguageCode = readLanguageCode(raw);
+            info.sourceLanguage = iso1FromIso3(info.sourceLanguageCode);
+        }
+        catch {
+            // unreadable transcript — leave language unknown
+        }
+    }
+    return info;
+}
+export function getRenderSettingsDef(engine) {
+    return {
+        name: "get_render_settings",
+        description: "Fetch stored render settings for a single asset across all orientations, plus transcript language info (detected source language and cached subtitle translations)",
+        schema: {
+            asset_id: z.string().describe("Asset ID (e.g. vid-running-dog)"),
+            book_id: z.string().describe("Book id"),
+        },
+        handler: async (args) => {
+            const { asset_id } = args;
+            const [settings, transcript] = await Promise.all([
+                readRenderSettings(engine, asset_id, [...RENDER_ORIENTATIONS]),
+                readTranscriptInfo(engine, asset_id),
+            ]);
+            return {
+                content: [{ type: "text", text: JSON.stringify({ settings, transcript }) }],
+            };
+        },
+    };
+}

package/dist/tools/render-timeline.js

@@ -0,0 +1,120 @@
+import { join } from "node:path";
+import { findAudioFile } from "videobook-engine";
+import { z } from "zod";
+import { queue } from "../queue.js";
+import { readTimeline } from "../timeline-helpers.js";
+const TIMELINE_FPS = 30;
+const RENDER_FILENAMES = {
+    landscape: "landscape.mp4",
+    portrait: "portrait.mp4",
+    square: "square.mp4",
+};
+async function runRenderTimeline(engine, bookId, orientationOverride) {
+    const timeline = readTimeline(engine);
+    const orientation = orientationOverride ?? timeline.render;
+    if (timeline.slots.length === 0) {
+        return { status: "empty", message: "Timeline has no assigned artifacts." };
+    }
+    const renderFilename = RENDER_FILENAMES[orientation];
+    const resolvedSlots = [];
+    const missingArtifactIds = [];
+    for (const slot of timeline.slots) {
+        const artifact = engine.artifacts.get(slot.artifactId);
+        if (!artifact.ok)
+            return { status: "error", message: artifact.error.message };
+        const manifest = await engine.files.manifest(artifact.value.artifactId);
+        if (!manifest.ok)
+            return { status: "error", message: manifest.error.message };
+        if (!manifest.value.files.some((file) => file.name === renderFilename)) {
+            missingArtifactIds.push(artifact.value.artifactId);
+            continue;
+        }
+        resolvedSlots.push({
+            artifactId: artifact.value.artifactId,
+            volume: slot.volume ?? 100,
+            fadeIn: slot.audioFadeIn ?? 0,
+            fadeOut: slot.audioFadeOut ?? 0,
+            assetDir: manifest.value.path,
+        });
+    }
+    if (missingArtifactIds.length > 0) {
+        return {
+            status: "missing_renders",
+            orientation,
+            missingArtifactIds,
+            message: `Missing ${renderFilename} for ${missingArtifactIds.join(", ")}`,
+        };
+    }
+    const resolvedAudio = [];
+    for (const clip of timeline.audio) {
+        const artifact = engine.artifacts.get(clip.artifactId);
+        if (!artifact.ok)
+            return { status: "error", message: artifact.error.message };
+        const manifest = await engine.files.manifest(artifact.value.artifactId);
+        if (!manifest.ok)
+            return { status: "error", message: manifest.error.message };
+        const audioFile = findAudioFile(manifest.value.files, artifact.value.kind);
+        if (!audioFile)
+            return { status: "error", message: `No audio file found in ${artifact.value.artifactId}` };
+        resolvedAudio.push({
+            id: clip.id,
+            artifactId: artifact.value.artifactId,
+            audioPath: join(manifest.value.path, audioFile.name),
+            startMs: Math.round((clip.startFrame / TIMELINE_FPS) * 1000),
+            durationMs: Math.round((clip.durationFrames / TIMELINE_FPS) * 1000),
+            volume: (clip.volume ?? 100) / 100,
+            fadeInMs: clip.fadeIn ?? 0,
+            fadeOutMs: clip.fadeOut ?? 0,
+        });
+    }
+    const jobId = `render-timeline-${bookId}-${Date.now()}`;
+    await queue.enqueue(jobId, {
+        type: "render_timeline",
+        bookId,
+        orientation,
+        resolvedSlots,
+        resolvedAudio,
+    });
+    return { status: "enqueued", jobId, slotCount: resolvedSlots.length, orientation };
+}
+export function renderTimelineDef(engine) {
+    return {
+        name: "render_timeline",
+        description: "Render the selected book's typed v2 timeline",
+        schema: {
+            book_id: z.string().uuid(),
+            orientation: z.enum(["landscape", "portrait", "square"]).optional(),
+        },
+        handler: async (args) => {
+            const outcome = await runRenderTimeline(engine, String(args.book_id), args.orientation);
+            if (outcome.status === "error" || outcome.status === "empty") {
+                return { isError: true, content: [{ type: "text", text: outcome.message }] };
+            }
+            if (outcome.status === "missing_renders") {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: outcome.status,
+                                orientation: outcome.orientation,
+                                missing_artifact_ids: outcome.missingArtifactIds,
+                                message: outcome.message,
+                            }),
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            status: outcome.status,
+                            job_id: outcome.jobId,
+                            slot_count: outcome.slotCount,
+                            orientation: outcome.orientation,
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/render.js

@@ -0,0 +1,384 @@
+import { z } from "zod";
+import { join } from "node:path";
+import { logger } from "../logger.js";
+import { queue } from "../queue.js";
+import { findVideoFile } from "videobook-engine";
+import { isValidHex } from "../remotion/util.js";
+import { requireArtifactKind } from "./_shared.js";
+import { isOsgPosition, isOsgSize, resolveOsgImagePath } from "../osg-assets.js";
+import { readTimeline, timelineInput, writeTimeline, } from "../timeline-helpers.js";
+import { DEFAULT_KEYWORD_GRAPHICS_LINGER_SECONDS, DEFAULT_KEYWORD_GRAPHICS_MAX_COUNT, } from "../remotion/keyword-graphics.js";
+export function renderVideoDef(engine) {
+    return {
+        name: "render_video",
+        description: "Render a video artifact into landscape.mp4, portrait.mp4, or square.mp4. Renders all 3 orientations when orientation is omitted.",
+        schema: {
+            asset_id: z.string().describe("Video artifact id"),
+            book_id: z.string().describe("Book id"),
+            orientation: z
+                .enum(["landscape", "portrait", "square"])
+                .optional()
+                .describe("Render one orientation; omit to render all three orientations"),
+            subtitles_enabled: z
+                .boolean()
+                .optional()
+                .describe("Enable subtitle overlay (default: false)"),
+            subtitle_language: z
+                .string()
+                .regex(/^(original|[a-z]{2})$/)
+                .optional()
+                .describe("Subtitle language: 'original' or a two-letter ISO 639-1 code (e.g. 'en'). Lazily translates and caches elevenlabs.<lang>.json (default: original)"),
+            highlight_style: z
+                .enum(["impact", "highlight", "alive"])
+                .optional()
+                .describe("Subtitle animation style (default: impact). alive renders stacked, frame-aware, audio-timed captions configured by set_alive_captions"),
+            position: z
+                .enum(["top", "middle", "bottom"])
+                .optional()
+                .describe("Subtitle vertical position (default: bottom)"),
+            font_size: z
+                .enum(["small", "medium", "large"])
+                .optional()
+                .describe("Subtitle font size (default: medium)"),
+            text_color: z
+                .string()
+                .optional()
+                .describe("Subtitle text color hex (default: #F8FAFC)"),
+            highlight_color: z
+                .string()
+                .optional()
+                .describe("Active word box color hex for highlight style (default: #991B1B)"),
+            audio_fade_in: z
+                .number()
+                .optional()
+                .describe("Audio fade-in in ms (default: 0)"),
+            audio_fade_out: z
+                .number()
+                .optional()
+                .describe("Audio fade-out in ms (default: 0)"),
+            audio_volume: z
+                .number()
+                .optional()
+                .describe("Audio volume percent 0-100 (default: 100)"),
+            osg_asset_id: z
+                .string()
+                .optional()
+                .describe("Image asset ID (img- prefix) for on-screen graphic overlay"),
+            osg_position: z
+                .enum([
+                "top-left", "top-center", "top-right",
+                "middle-left", "middle-center", "middle-right",
+                "bottom-left", "bottom-center", "bottom-right",
+            ])
+                .optional()
+                .describe("OSG position (default: top-right)"),
+            osg_size: z
+                .enum(["small", "medium", "large"])
+                .optional()
+                .describe("OSG size preset; small ≈ half (default: medium)"),
+            osg_scale: z
+                .number()
+                .min(0.1)
+                .max(2)
+                .optional()
+                .describe("OSG size multiplier applied on top of osg_size (default: 1)"),
+            osg_opacity: z
+                .number()
+                .min(0.05)
+                .max(1)
+                .optional()
+                .describe("OSG opacity 0.05-1; the floating watermark uses 0.5 (default: 1)"),
+            osg_start_seconds: z
+                .number()
+                .min(0)
+                .nullable()
+                .optional()
+                .describe("OSG visibility window start in seconds; null/omit ⇒ from clip start"),
+            osg_end_seconds: z
+                .number()
+                .min(0)
+                .nullable()
+                .optional()
+                .describe("OSG visibility window end in seconds; null/omit ⇒ to clip end"),
+            keyword_graphics_enabled: z
+                .boolean()
+                .optional()
+                .describe("Enable transcript-timed cinematic keyword graphics (default: stored setting or false)"),
+            keyword_graphics_max_count: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .optional()
+                .describe("Maximum automatic keyword graphics (default: stored setting or 8)"),
+            keyword_graphics_linger_seconds: z
+                .number()
+                .min(0.8)
+                .max(5)
+                .optional()
+                .describe("How long each keyword lingers after it is spoken (default: stored setting or 2.4 seconds)"),
+            keyword_graphics_keywords: z
+                .array(z.string().min(1))
+                .max(20)
+                .nullable()
+                .optional()
+                .describe("Exact transcript keywords to animate; null selects keywords automatically"),
+            background_mode: z
+                .enum(["blur", "black"])
+                .optional()
+                .describe("Background fill mode (default: blur)"),
+            stroke_width: z
+                .number()
+                .optional()
+                .describe("Subtitle stroke width in px, 0-20 (default: 6)"),
+            stroke_color: z
+                .string()
+                .optional()
+                .describe("Subtitle stroke color hex (default: #000000)"),
+            shadow_blur: z
+                .number()
+                .optional()
+                .describe("Subtitle shadow blur in px, 0-30 (default: 6)"),
+            shadow_opacity: z
+                .number()
+                .optional()
+                .describe("Subtitle shadow opacity 0-100 (default: 60)"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, orientation: explicitOrientation, subtitles_enabled, subtitle_language = "original", highlight_style = "impact", position = "bottom", font_size = "medium", text_color = "#F8FAFC", highlight_color = "#991B1B", audio_fade_in = 0, audio_fade_out = 0, audio_volume = 100, osg_asset_id, osg_position, osg_size, osg_scale, osg_opacity, osg_start_seconds, osg_end_seconds, keyword_graphics_enabled, keyword_graphics_max_count, keyword_graphics_linger_seconds, keyword_graphics_keywords, background_mode = "blur", stroke_width = 6, stroke_color = "#000000", shadow_blur = 6, shadow_opacity = 60, } = args;
+            const kindGate = await requireArtifactKind(engine, asset_id, ["video"], "render_video");
+            if (kindGate)
+                return kindGate;
+            if (text_color && !isValidHex(text_color)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Invalid text_color hex: ${text_color}` }],
+                };
+            }
+            if (highlight_color && !isValidHex(highlight_color)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Invalid highlight_color hex: ${highlight_color}` }],
+                };
+            }
+            if (audio_volume < 0 || audio_volume > 100) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "audio_volume must be 0-100" }],
+                };
+            }
+            if (audio_fade_in < 0 || audio_fade_out < 0) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "audio fade values must be >= 0" }],
+                };
+            }
+            if (stroke_width < 0 || stroke_width > 20) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "stroke_width must be 0-20" }],
+                };
+            }
+            if (stroke_color && !isValidHex(stroke_color)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Invalid stroke_color hex: ${stroke_color}` }],
+                };
+            }
+            if (shadow_blur < 0 || shadow_blur > 30) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "shadow_blur must be 0-30" }],
+                };
+            }
+            if (shadow_opacity < 0 || shadow_opacity > 100) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "shadow_opacity must be 0-100" }],
+                };
+            }
+            // Determine orientations to render
+            const ALL_ORIENTATIONS = ["landscape", "portrait", "square"];
+            const orientations = explicitOrientation
+                ? [explicitOrientation]
+                : ALL_ORIENTATIONS;
+            const manifestResult = await engine.files.manifest(asset_id);
+            if (!manifestResult.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: manifestResult.error.message }],
+                };
+            }
+            const manifest = manifestResult.value;
+            const videoFile = findVideoFile(manifest.files);
+            if (!videoFile) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `No video file found in asset ${asset_id}` }],
+                };
+            }
+            const subsEnabled = subtitles_enabled ?? false;
+            // Resolve an explicitly passed OSG image up front so a bad reference
+            // fails the tool call. Stored per-orientation OSG settings are resolved
+            // inside the orientation loop instead (a stale stored id skips the OSG
+            // rather than failing the render).
+            let osgImagePath = null;
+            if (osg_asset_id) {
+                const osgGate = await requireArtifactKind(engine, osg_asset_id, ["image"], "osg_asset_id");
+                if (osgGate)
+                    return osgGate;
+                const resolved = await resolveOsgImagePath(engine, osg_asset_id);
+                if (!resolved.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: resolved.error }],
+                    };
+                }
+                osgImagePath = resolved.path;
+            }
+            const storedOsgPathCache = new Map();
+            // A previously failed job leaves the assets row at status='error',
+            // which beginAssetWork refuses to lease — and enqueue never resets it.
+            // An explicit render is a retry: clear the stale failure first so the
+            // new jobs can claim the asset.
+            const clearResult = await engine.jobs.failures.clear(asset_id);
+            if (!clearResult.ok) {
+                logger.warn("generation-error-clear-failed", { assetId: asset_id, error: clearResult.error });
+            }
+            const assetDir = manifest.path;
+            const videoPath = join(assetDir, videoFile.name);
+            const jobs = [];
+            for (const orientation of orientations) {
+                const storedResult = await engine.metadata.artifacts.read(asset_id, `${orientation}.render`);
+                const stored = storedResult.ok ? storedResult.value : {};
+                const storedMaxCount = stored.keywordGraphicsMaxCount;
+                const storedLingerSeconds = stored.keywordGraphicsLingerSeconds;
+                const storedKeywords = stored.keywordGraphicsKeywords;
+                const keywordGraphicsEnabled = keyword_graphics_enabled
+                    ?? stored.keywordGraphicsEnabled === true;
+                const keywordGraphicsMaxCount = keyword_graphics_max_count
+                    ?? (typeof storedMaxCount === "number" && Number.isInteger(storedMaxCount) && storedMaxCount >= 1 && storedMaxCount <= 20
+                        ? storedMaxCount
+                        : DEFAULT_KEYWORD_GRAPHICS_MAX_COUNT);
+                const keywordGraphicsLingerSeconds = keyword_graphics_linger_seconds
+                    ?? (typeof storedLingerSeconds === "number" && storedLingerSeconds >= 0.8 && storedLingerSeconds <= 5
+                        ? storedLingerSeconds
+                        : DEFAULT_KEYWORD_GRAPHICS_LINGER_SECONDS);
+                const keywordGraphicsKeywords = keyword_graphics_keywords !== undefined
+                    ? keyword_graphics_keywords
+                    : Array.isArray(storedKeywords) && storedKeywords.every((keyword) => typeof keyword === "string")
+                        ? storedKeywords
+                        : null;
+                // Explicit OSG args win; else fall back to the settings set_video_overlay
+                // stored on this orientation (position may differ per orientation — the
+                // frame-aware watermark picks a corner for each).
+                const storedOsgAssetId = typeof stored.osgAssetId === "string" && stored.osgAssetId.length > 0
+                    ? stored.osgAssetId
+                    : null;
+                let orientOsgAssetId = osg_asset_id ?? storedOsgAssetId;
+                let orientOsgImagePath = osgImagePath;
+                if (!osg_asset_id && storedOsgAssetId) {
+                    if (!storedOsgPathCache.has(storedOsgAssetId)) {
+                        const resolved = await resolveOsgImagePath(engine, storedOsgAssetId);
+                        if (!resolved.ok) {
+                            logger.warn("overlay-skipped", { assetId: storedOsgAssetId, error: resolved.error });
+                        }
+                        storedOsgPathCache.set(storedOsgAssetId, resolved.ok ? resolved.path : null);
+                    }
+                    orientOsgImagePath = storedOsgPathCache.get(storedOsgAssetId) ?? null;
+                    if (orientOsgImagePath === null)
+                        orientOsgAssetId = null;
+                }
+                const osgPosition = osg_position
+                    ?? (isOsgPosition(stored.osgPosition) ? stored.osgPosition : "top-right");
+                const osgSize = osg_size
+                    ?? (isOsgSize(stored.osgSize) ? stored.osgSize : "medium");
+                const osgScale = osg_scale
+                    ?? (typeof stored.osgScale === "number" && Number.isFinite(stored.osgScale) ? stored.osgScale : 1);
+                const osgOpacity = osg_opacity
+                    ?? (typeof stored.osgOpacity === "number" && stored.osgOpacity >= 0.05 && stored.osgOpacity <= 1
+                        ? stored.osgOpacity
+                        : 1);
+                const osgStartSeconds = osg_start_seconds !== undefined
+                    ? osg_start_seconds
+                    : typeof stored.osgStartSeconds === "number" ? stored.osgStartSeconds : null;
+                const osgEndSeconds = osg_end_seconds !== undefined
+                    ? osg_end_seconds
+                    : typeof stored.osgEndSeconds === "number" ? stored.osgEndSeconds : null;
+                const osgTailSeconds = typeof stored.osgTailSeconds === "number" ? stored.osgTailSeconds : null;
+                const jobId = `render-${asset_id}-${orientation}-${Date.now()}`;
+                await queue.enqueue(jobId, {
+                    type: "render_project",
+                    bookId: book_id,
+                    assetId: asset_id,
+                    orientation,
+                    assets: [{
+                            assetId: asset_id,
+                            assetDir,
+                            videoPath,
+                            videoFilename: videoFile.name,
+                        }],
+                    subtitlesEnabled: subsEnabled,
+                    subtitleLanguage: subtitle_language,
+                    highlightStyle: highlight_style,
+                    position,
+                    fontSize: font_size,
+                    textColor: text_color,
+                    highlightColor: highlight_color,
+                    audioFadeIn: audio_fade_in,
+                    audioFadeOut: audio_fade_out,
+                    audioVolume: audio_volume,
+                    osgImagePath: orientOsgImagePath,
+                    osgAssetId: orientOsgAssetId ?? null,
+                    osgPosition,
+                    osgSize,
+                    osgScale,
+                    osgOpacity,
+                    osgStartSeconds,
+                    osgEndSeconds,
+                    osgTailSeconds,
+                    keywordGraphicsEnabled,
+                    keywordGraphicsMaxCount,
+                    keywordGraphicsLingerSeconds,
+                    keywordGraphicsKeywords,
+                    backgroundMode: background_mode,
+                    strokeWidth: stroke_width,
+                    strokeColor: stroke_color,
+                    shadowBlur: shadow_blur,
+                    shadowOpacity: shadow_opacity,
+                });
+                jobs.push({ job_id: jobId, orientation });
+            }
+            // Persist the requested orientation as the project's timeline render
+            // orientation so /final and the viewer agree on what to produce.
+            let savedOrientation;
+            if (explicitOrientation) {
+                try {
+                    const timeline = readTimeline(engine);
+                    const updated = await writeTimeline(engine, {
+                        ...timelineInput(timeline),
+                        render: explicitOrientation,
+                    });
+                    if (!updated.ok)
+                        throw new Error(updated.error.message);
+                    savedOrientation = explicitOrientation;
+                }
+                catch (err) {
+                    logger.warn("timeline-orientation-failed", { error: err });
+                }
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            asset_id,
+                            orientations: orientations,
+                            jobs,
+                            ...(savedOrientation !== undefined && { timeline_render: savedOrientation }),
+                            status: "enqueued",
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/reorder-character-images.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { extname } from "node:path";
+export function reorderCharacterImagesDef(engine) {
+    return {
+        name: "reorder_character_images",
+        description: "Reorder images in a character folder by renaming them sequentially (source-01, source-02, etc).",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            asset_id: z.string().describe("Character asset ID"),
+            ordered_filenames: z.array(z.string()).describe("List of image filenames in the desired new order"),
+        },
+        handler: async (payload) => {
+            const { book_id: _book_id, asset_id, ordered_filenames } = payload;
+            // Step 1: Rename all to temporary names to avoid collisions
+            const tempNames = [];
+            for (let i = 0; i < ordered_filenames.length; i++) {
+                const oldName = ordered_filenames[i];
+                const ext = extname(oldName).replace(/^\./, "") || "jpg";
+                const tempName = `.tmp-reorder-${Date.now()}-${i}.${ext}`;
+                const newName = `source-${String(i + 1).padStart(2, '0')}.${ext}`;
+                const renameRes = await engine.files.rename(asset_id, oldName, tempName);
+                if (!renameRes.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `Failed to rename ${oldName} to temp name: ${renameRes.error.message}` }],
+                    };
+                }
+                tempNames.push({ oldName, tempName, newName });
+            }
+            // Step 2: Rename from temp names to final sequence names
+            for (const mapping of tempNames) {
+                const renameRes = await engine.files.rename(asset_id, mapping.tempName, mapping.newName);
+                if (!renameRes.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `Failed to rename temp file to ${mapping.newName}: ${renameRes.error.message}` }],
+                    };
+                }
+            }
+            return {
+                content: [{ type: "text", text: "Successfully reordered character images." }],
+            };
+        },
+    };
+}