videobook 0.0.0-stage → 0.2.0

package/dist/jobs/burn-watermark.js

@@ -0,0 +1,316 @@
+import { rm } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { AUDIO_OPTS, H264_MEDIUM, probeVideo, runFfmpeg } from "../ffmpeg.js";
+import { logger } from "../logger.js";
+import { queue, registerJobHandler } from "../queue.js";
+import { scoreWatermarkCornersForCanvas, WATERMARK_MIN_DIM_FRACTION, WATERMARK_OPACITY, } from "../remotion/osg-spec.js";
+import { BADGE_WIDTH, DEFAULT_HANDLE_PADDING, HANDLE_ONLY_BADGE_HEIGHT, handlePillHeight, } from "../watermark-badge.js";
+import { DEFAULT_HANDLE_VERTICAL_PERCENT, watermarkHandleOverlayPosition, } from "../watermark-handle-position.js";
+import { analyzeOsgPlacement } from "./osg-placement.js";
+import { replaceArtifactFileFromPath } from "./_persist-output.js";
+import { withLockedLocalLease } from "./_lease.js";
+import { effectiveWatermarkTiming } from "../watermark-timing.js";
+const LOCK_DURATION_MS = 600_000;
+/** Fade applied at a watermark edge that falls inside the clip. */
+const DEFAULT_WATERMARK_FADE_SECONDS = 0.5;
+export const MAX_WATERMARK_FADE_SECONDS = 2;
+/** Extra looped badge frames past the last fade so overlay never runs dry mid-ramp. */
+const LOOP_MARGIN_SECONDS = 0.25;
+/** Ends this close to the clip end count as "whole clip": no fade out. */
+const CLIP_END_TOLERANCE_SECONDS = 0.001;
+const NO_FADES = { fadeIn: 0, fadeOut: 0 };
+function roundSeconds(value) {
+    return Math.round(value * 1000) / 1000;
+}
+/** ffmpeg overlay x/y expressions for a corner, inset by `padding` pixels. */
+function burnOverlayPosition(corner, padding) {
+    const [vertical, horizontal] = corner.split("-");
+    const x = horizontal === "left"
+        ? String(padding)
+        : horizontal === "right"
+            ? `main_w-overlay_w-${padding}`
+            : "(main_w-overlay_w)/2";
+    const y = vertical === "top"
+        ? String(padding)
+        : vertical === "bottom"
+            ? `main_h-overlay_h-${padding}`
+            : "(main_h-overlay_h)/2";
+    return { x, y };
+}
+export function burnWatermarkEnable(startSeconds, endSeconds) {
+    if (startSeconds === undefined && endSeconds === undefined)
+        return "";
+    const start = startSeconds ?? 0;
+    return endSeconds === undefined
+        ? `:enable='gte(t,${start})'`
+        : `:enable='between(t,${start},${endSeconds})'`;
+}
+/**
+ * Fade lengths for one watermark window. A watermark fades in only when it
+ * starts after the clip start and out only when it ends before the clip end,
+ * so a whole-clip watermark keeps hard edges. Fades shrink to half the window
+ * so a short window still reaches full opacity in the middle.
+ */
+export function burnWatermarkFades(startSeconds, endSeconds, durationSeconds, fadeSeconds) {
+    const start = Math.max(0, startSeconds ?? 0);
+    const clipEnd = endSeconds === undefined
+        ? durationSeconds
+        : Math.min(endSeconds, durationSeconds);
+    const window = clipEnd - start;
+    if (!(fadeSeconds > 0) || !(window > 0))
+        return NO_FADES;
+    const fade = roundSeconds(Math.min(fadeSeconds, window / 2));
+    const endsEarly = endSeconds !== undefined
+        && endSeconds < durationSeconds - CLIP_END_TOLERANCE_SECONDS;
+    return {
+        fadeIn: start > 0 ? fade : 0,
+        fadeOut: endsEarly ? fade : 0,
+    };
+}
+/**
+ * Alpha fades appended to a badge input chain. The badge input must be a
+ * timed stream (see `burnWatermarkInputArgs`) for the fade timestamps to
+ * line up with the main video.
+ */
+function burnWatermarkFadeFilters(fades, startSeconds, endSeconds) {
+    const parts = [];
+    if (fades.fadeIn > 0) {
+        parts.push(`fade=t=in:st=${startSeconds ?? 0}:d=${fades.fadeIn}:alpha=1`);
+    }
+    if (fades.fadeOut > 0 && endSeconds !== undefined) {
+        parts.push(`fade=t=out:st=${roundSeconds(endSeconds - fades.fadeOut)}:d=${fades.fadeOut}:alpha=1`);
+    }
+    return parts.map((part) => `,${part}`).join("");
+}
+/**
+ * How long the looped badge stream must run for its fades to complete: past
+ * the last ramp the badge is static, and overlay repeats the final frame for
+ * the rest of the clip. Null when the badge needs no fades and a single still
+ * frame does.
+ */
+export function burnWatermarkLoopSeconds(fades, startSeconds, endSeconds, durationSeconds) {
+    if (fades.fadeIn === 0 && fades.fadeOut === 0)
+        return null;
+    const settledAt = fades.fadeOut > 0 && endSeconds !== undefined
+        ? endSeconds
+        : (startSeconds ?? 0) + fades.fadeIn;
+    return roundSeconds(Math.min(durationSeconds, settledAt + LOOP_MARGIN_SECONDS));
+}
+/** Input args for one badge image: a still frame, or a timed loop when it fades. */
+export function burnWatermarkInputArgs(path, loopSeconds, frameRate) {
+    return loopSeconds === null
+        ? ["-i", path]
+        : ["-loop", "1", "-framerate", frameRate, "-t", String(loopSeconds), "-i", path];
+}
+function burnWatermarkFrameRate(probe) {
+    const nominal = probe.videoStream?.video?.nominalFrameRate;
+    if (nominal && nominal.numerator > 0 && nominal.denominator > 0) {
+        return `${nominal.numerator}/${nominal.denominator}`;
+    }
+    return String(roundSeconds(probe.fps > 0 ? probe.fps : 30));
+}
+export function buildBurnWatermarkFilter(options) {
+    const minDim = Math.min(options.width, options.height);
+    const badgeHeight = Math.max(2, 2 * Math.round((minDim * WATERMARK_MIN_DIM_FRACTION * options.userScale) / 2));
+    const padding = Math.round(options.width * 0.02);
+    const { x, y } = burnOverlayPosition(options.corner, padding);
+    const handlePlacement = options.includeQr && options.handlePlacement
+        ? options.handlePlacement
+        : "center";
+    const attachedToQr = handlePlacement !== "center";
+    const handleBadgeHeight = handlePillHeight(options.handlePaddingY ?? DEFAULT_HANDLE_PADDING);
+    const independentHandleHeight = Math.max(2, 2 * Math.round((badgeHeight * handleBadgeHeight / HANDLE_ONLY_BADGE_HEIGHT) / 2));
+    const attachedHandleHeight = Math.max(2, Math.round(badgeHeight * handleBadgeHeight / BADGE_WIDTH));
+    const handleScale = attachedToQr
+        ? `${badgeHeight}:-2`
+        : `-2:${independentHandleHeight}`;
+    const handleOverlay = watermarkHandleOverlayPosition({
+        placement: handlePlacement,
+        corner: options.corner,
+        canvasWidth: options.width,
+        canvasHeight: options.height,
+        qrSize: badgeHeight,
+        handleWidth: attachedToQr
+            ? badgeHeight
+            : Math.round(independentHandleHeight * BADGE_WIDTH / handleBadgeHeight),
+        handleHeight: attachedToQr ? attachedHandleHeight : independentHandleHeight,
+        padding,
+        handleVerticalPercent: options.handleVerticalPercent ?? DEFAULT_HANDLE_VERTICAL_PERCENT,
+    });
+    const sharedOpacity = options.opacity ?? WATERMARK_OPACITY;
+    const qrOpacity = options.qrOpacity ?? sharedOpacity;
+    const handleOpacity = options.handleOpacity ?? sharedOpacity;
+    const qrStart = options.qrStartSeconds ?? options.startSeconds;
+    const qrEnd = options.qrEndSeconds ?? options.endSeconds;
+    const handleStart = options.handleStartSeconds ?? options.startSeconds;
+    const handleEnd = options.handleEndSeconds ?? options.endSeconds;
+    const fadesFor = (start, end) => options.durationSeconds !== undefined && options.fadeSeconds !== undefined
+        ? burnWatermarkFades(start, end, options.durationSeconds, options.fadeSeconds)
+        : NO_FADES;
+    const qrFade = burnWatermarkFadeFilters(fadesFor(qrStart, qrEnd), qrStart, qrEnd);
+    const handleFade = burnWatermarkFadeFilters(fadesFor(handleStart, handleEnd), handleStart, handleEnd);
+    const qrEnable = burnWatermarkEnable(qrStart, qrEnd);
+    const handleEnable = burnWatermarkEnable(handleStart, handleEnd);
+    const handleInput = options.includeQr ? 2 : 1;
+    if (!options.includeQr && !options.includeHandle) {
+        throw new Error("QR or handle watermark input is required");
+    }
+    const filters = [];
+    if (options.includeQr) {
+        filters.push(`[1:v]scale=-2:${badgeHeight},format=rgba,colorchannelmixer=aa=${qrOpacity}${qrFade}[qr]`);
+    }
+    if (options.includeHandle) {
+        filters.push(`[${handleInput}:v]scale=${handleScale},format=rgba,colorchannelmixer=aa=${handleOpacity}${handleFade}[handle]`);
+    }
+    if (options.includeQr) {
+        const output = options.includeHandle ? "withqr" : "vout";
+        filters.push(`[0:v][qr]overlay=${x}:${y}:format=auto${qrEnable}[${output}]`);
+    }
+    if (options.includeHandle) {
+        const base = options.includeQr ? "withqr" : "0:v";
+        filters.push(`[${base}][handle]overlay=${handleOverlay.x}:${handleOverlay.y}:format=auto${handleEnable}[vout]`);
+    }
+    return filters.join(";");
+}
+function badgeInputArgs(path, timing, probe, fadeSeconds) {
+    const fades = burnWatermarkFades(timing.startSeconds, timing.endSeconds, probe.videoDuration, fadeSeconds);
+    const loopSeconds = burnWatermarkLoopSeconds(fades, timing.startSeconds, timing.endSeconds, probe.videoDuration);
+    return burnWatermarkInputArgs(path, loopSeconds, burnWatermarkFrameRate(probe));
+}
+/**
+ * Resolve the QR corner inside the job: a deferred vision pass when the tool
+ * asked for one, otherwise the corner the tool already settled on. Vision
+ * failures degrade to the tool's fallback rather than failing the burn.
+ */
+async function resolveBurnCorner(engine, payload, probe, signal) {
+    const fallback = {
+        corner: payload.corner,
+        placementSource: payload.placementSource ?? "explicit",
+    };
+    if (!payload.placement)
+        return fallback;
+    try {
+        const analysis = await analyzeOsgPlacement(engine, {
+            assetId: payload.assetId,
+            fingerprint: payload.placement.fingerprint,
+            userScale: payload.userScale,
+            badgeAspect: payload.placement.badgeAspect,
+            signal,
+        });
+        // Score corners against the source frame itself — a burned watermark
+        // lives in source pixels, so one corner serves every orientation.
+        const corner = scoreWatermarkCornersForCanvas(probe.width, probe.height, analysis.regions, {
+            aspect: payload.placement.badgeAspect,
+            userScale: payload.userScale,
+        }).position;
+        return { corner, placementSource: "vision" };
+    }
+    catch (err) {
+        signal.throwIfAborted();
+        logger.warn("watermark-placement-fallback", { assetId: payload.assetId, error: err });
+        return fallback;
+    }
+}
+/**
+ * Composite the watermark badge onto the source video: scaled to the min-dim
+ * fraction the render-time overlay uses, faded to `opacity`, anchored at
+ * `corner` with the standard edge padding, and faded in/out at any edge that
+ * falls inside the clip. Mirrors the trim/crop shape: replace the canonical
+ * file in place, drop stale visual analysis, reprocess.
+ */
+export function registerBurnWatermarkJob(engine) {
+    registerJobHandler("burn_watermark", async (rawPayload, ctx) => {
+        const payload = rawPayload;
+        const { assetId, assetDir, bookId, videoPath, qrPath, handlePath, opacity, userScale, qrOpacity, handleOpacity, handleVerticalPercent = DEFAULT_HANDLE_VERTICAL_PERCENT, handlePlacement = "center", handlePaddingY = DEFAULT_HANDLE_PADDING, fadeSeconds = DEFAULT_WATERMARK_FADE_SECONDS, startSeconds, endSeconds, qrStartSeconds, qrEndSeconds, handleStartSeconds, handleEndSeconds, } = payload;
+        const result = await withLockedLocalLease(engine, assetId, assetDir, ctx, "process", { durationMs: LOCK_DURATION_MS, data: { state: "burning-watermark" } }, async () => {
+            const probe = await probeVideo(videoPath, { signal: ctx.signal });
+            const handleTiming = handlePath
+                ? effectiveWatermarkTiming("Handle watermark", probe.videoDuration, handleStartSeconds ?? startSeconds, handleEndSeconds ?? endSeconds)
+                : {};
+            const qrTiming = qrPath
+                ? effectiveWatermarkTiming("QR watermark", probe.videoDuration, qrStartSeconds ?? startSeconds, qrEndSeconds ?? endSeconds)
+                : {};
+            const placement = await resolveBurnCorner(engine, payload, probe, ctx.signal);
+            const outputPath = join(assetDir, "original_watermarked.mp4");
+            const filter = buildBurnWatermarkFilter({
+                width: probe.width,
+                height: probe.height,
+                corner: placement.corner,
+                opacity,
+                qrOpacity,
+                handleOpacity,
+                userScale,
+                includeQr: qrPath !== undefined,
+                includeHandle: handlePath !== undefined,
+                handleVerticalPercent,
+                handlePlacement,
+                handlePaddingY,
+                durationSeconds: probe.videoDuration,
+                fadeSeconds,
+                ...(qrTiming.startSeconds !== undefined
+                    ? { qrStartSeconds: qrTiming.startSeconds }
+                    : {}),
+                ...(qrTiming.endSeconds !== undefined
+                    ? { qrEndSeconds: qrTiming.endSeconds }
+                    : {}),
+                ...(handleTiming.startSeconds !== undefined
+                    ? { handleStartSeconds: handleTiming.startSeconds }
+                    : {}),
+                ...(handleTiming.endSeconds !== undefined
+                    ? { handleEndSeconds: handleTiming.endSeconds }
+                    : {}),
+            });
+            const watermarkInputs = [
+                ...(qrPath ? badgeInputArgs(qrPath, qrTiming, probe, fadeSeconds) : []),
+                ...(handlePath ? badgeInputArgs(handlePath, handleTiming, probe, fadeSeconds) : []),
+            ];
+            try {
+                await runFfmpeg([
+                    "-y",
+                    "-i", videoPath,
+                    ...watermarkInputs,
+                    "-filter_complex", filter,
+                    "-map", "[vout]",
+                    "-map", "0:a?",
+                    ...H264_MEDIUM,
+                    "-pix_fmt", "yuv420p",
+                    ...AUDIO_OPTS,
+                    outputPath,
+                ], { signal: ctx.signal });
+                const check = await probeVideo(outputPath, { signal: ctx.signal });
+                if (check.width !== probe.width || check.height !== probe.height
+                    || Math.abs(check.duration - probe.duration) > 0.5) {
+                    throw new Error(`Watermarked output looks wrong: ${check.width}x${check.height} ${check.duration.toFixed(2)}s`
+                        + ` from ${probe.width}x${probe.height} ${probe.duration.toFixed(2)}s`);
+                }
+            }
+            catch (err) {
+                await rm(outputPath, { force: true });
+                throw err;
+            }
+            const inputFilename = basename(videoPath);
+            await replaceArtifactFileFromPath(engine, assetId, inputFilename, outputPath);
+            // Visual analysis now describes the un-watermarked frames; transcripts
+            // stay valid (audio and timing are untouched).
+            await engine.files.delete(assetId, ".original.analysis.json");
+            return { videoPath: join(assetDir, inputFilename), placement };
+        }, { durationMs: LOCK_DURATION_MS, waitForActiveMs: 30_000 });
+        // The badge now lives in the pixels. The forced reprocess drops every
+        // stored render-time overlay setting, so a later render can't stamp it
+        // twice.
+        await queue.enqueue(`process-video-${assetId}-${Date.now()}`, {
+            type: "process_video",
+            videoPath: result.videoPath,
+            assetId,
+            assetDir,
+            bookId,
+            provenance: { origin: "watermark", watermarked_at: new Date().toISOString() },
+            force: true,
+        });
+        return {
+            success: true,
+            corner: result.placement.corner,
+            placementSource: result.placement.placementSource,
+        };
+    });
+}

package/dist/jobs/change-video-speed.js

@@ -0,0 +1,176 @@
+import { execFile } from "node:child_process";
+import { rm } from "node:fs/promises";
+import { promisify } from "node:util";
+import { basename, join } from "node:path";
+import { registerJobHandler, queue } from "../queue.js";
+import { getFFmpeggy, probeVideo, FFPROBE, H264_MEDIUM, AUDIO_OPTS, } from "../ffmpeg.js";
+import { withLockedLocalLease } from "./_lease.js";
+import { replaceArtifactFileFromPath } from "./_persist-output.js";
+const execFileAsync = promisify(execFile);
+const LOCK_DURATION_MS = 300_000;
+const ATEMPO_MIN = 0.5;
+// The muxer can pad the final frame's display duration past the ideal end
+// (observed: 1.5 source frame intervals on B-frame sources); keep the
+// duration check as a backstop and let frame-count equality carry precision.
+const DURATION_FRAME_TOLERANCE = 1.5;
+const DURATION_SLACK_S = 0.03;
+const AUDIO_TOLERANCE_S = 0.15;
+function buildAtempoChain(speed) {
+    const filters = [];
+    let remaining = speed;
+    while (remaining < ATEMPO_MIN) {
+        filters.push(`atempo=${ATEMPO_MIN}`);
+        remaining /= ATEMPO_MIN;
+    }
+    filters.push(`atempo=${remaining}`);
+    return filters;
+}
+function buildSpeedOutputOptions(speed, hasAudio, targetDuration, outputFrameRate) {
+    const videoChain = [`settb=AVTB`, `setpts=(PTS-STARTPTS)/${speed}`];
+    const audioChain = ["asetpts=PTS-STARTPTS", ...buildAtempoChain(speed)];
+    if (targetDuration !== undefined) {
+        const cap = targetDuration.toFixed(6);
+        videoChain.push(`trim=end=${cap}`);
+        audioChain.push(`atrim=end=${cap}`);
+    }
+    const opts = [
+        "-fps_mode:v", outputFrameRate === undefined ? "passthrough" : "cfr",
+        ...(outputFrameRate === undefined ? [] : ["-r", String(outputFrameRate)]),
+        "-filter:v", videoChain.join(","),
+    ];
+    if (hasAudio) {
+        opts.push("-filter:a", audioChain.join(","));
+    }
+    else {
+        opts.push("-an");
+    }
+    opts.push(...H264_MEDIUM, ...AUDIO_OPTS);
+    return opts;
+}
+async function probeVideoFrameCount(filePath) {
+    try {
+        const { stdout } = await execFileAsync(FFPROBE, [
+            "-v", "error",
+            "-select_streams", "v:0",
+            "-show_entries", "stream=nb_frames",
+            "-of", "json",
+            filePath,
+        ]);
+        const data = JSON.parse(stdout);
+        const count = Number(data.streams?.[0]?.nb_frames);
+        return Number.isSafeInteger(count) && count > 0 ? count : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function hasConstantFrameSpacing(filePath) {
+    try {
+        const { stdout } = await execFileAsync(FFPROBE, [
+            "-v", "error",
+            "-select_streams", "v:0",
+            "-show_entries", "packet=pts",
+            "-of", "json",
+            filePath,
+        ], { maxBuffer: 16 * 1024 * 1024 });
+        const data = JSON.parse(stdout);
+        const times = data.packets?.map((packet) => Number(packet.pts)) ?? [];
+        if (times.length < 2 || times.some((time) => !Number.isSafeInteger(time)))
+            return false;
+        times.sort((a, b) => a - b);
+        const interval = (times[times.length - 1] - times[0]) / (times.length - 1);
+        return interval > 0 && times.slice(1).every((time, index) => (time > times[index] && Math.abs(time - times[index] - interval) <= 1));
+    }
+    catch {
+        return false;
+    }
+}
+function retimeValidationErrors(input, output, speed, targetDuration) {
+    const errors = [];
+    if (output.videoCodec === null || output.videoDuration <= 0) {
+        errors.push("output has no playable video stream");
+        return errors;
+    }
+    // In exact-duration mode the trim/atrim cap wins when a stream would
+    // overrun the target, so expectations clamp to the cap.
+    const cap = targetDuration ?? Number.POSITIVE_INFINITY;
+    const frameInterval = input.fps > 0 ? 1 / input.fps : 1 / 30;
+    const videoTolerance = DURATION_FRAME_TOLERANCE * frameInterval / speed + DURATION_SLACK_S;
+    const expectedVideo = Math.min(input.videoDuration / speed, cap);
+    if (Math.abs(output.videoDuration - expectedVideo) > videoTolerance) {
+        errors.push(`video duration ${output.videoDuration.toFixed(3)}s does not match expected`
+            + ` ${expectedVideo.toFixed(3)}s (source ${input.videoDuration.toFixed(3)}s at ${speed}x)`);
+    }
+    if (input.hasAudio) {
+        if (!output.hasAudio || output.audioDuration === null) {
+            errors.push("output lost the source audio track");
+        }
+        else {
+            const expectedAudio = Math.min((input.audioDuration ?? input.videoDuration) / speed, cap);
+            if (Math.abs(output.audioDuration - expectedAudio) > AUDIO_TOLERANCE_S) {
+                errors.push(`audio duration ${output.audioDuration.toFixed(3)}s does not match expected`
+                    + ` ${expectedAudio.toFixed(3)}s (source audio retimed at ${speed}x)`);
+            }
+        }
+    }
+    return errors;
+}
+export function registerChangeVideoSpeedJob(engine) {
+    registerJobHandler("change_video_speed", async (payload, ctx) => {
+        const { inputPath, outputPath, speed, targetDuration, hasAudio, assetId, assetDir, bookId, } = payload;
+        const result = await withLockedLocalLease(engine, assetId, assetDir, ctx, "change_speed", { durationMs: LOCK_DURATION_MS, data: { state: "changing-speed" } }, async () => {
+            const inputProbe = await probeVideo(inputPath);
+            const sourceFrameCount = await probeVideoFrameCount(inputPath);
+            const outputFrameRate = sourceFrameCount !== null && inputProbe.videoDuration > 0
+                && await hasConstantFrameSpacing(inputPath)
+                ? sourceFrameCount / (targetDuration ?? inputProbe.videoDuration / speed)
+                : undefined;
+            const outputOptions = buildSpeedOutputOptions(speed, hasAudio, targetDuration, outputFrameRate);
+            const FFmpeggy = await getFFmpeggy();
+            const ff = new FFmpeggy({
+                input: inputPath,
+                output: outputPath,
+                outputOptions,
+                overwriteExisting: true,
+            });
+            await ff.run();
+            await ff.done();
+            // Validate before touching canonical media: a retime that dropped
+            // frames, drifted from the expected duration, or lost the audio track
+            // must fail the job and leave the current version recoverable.
+            const outputProbe = await probeVideo(outputPath);
+            const errors = retimeValidationErrors(inputProbe, outputProbe, speed, targetDuration);
+            const outputFrameCount = await probeVideoFrameCount(outputPath);
+            if (sourceFrameCount !== null
+                && outputFrameCount !== null
+                && sourceFrameCount !== outputFrameCount) {
+                errors.push(`video frame count ${outputFrameCount} does not match source ${sourceFrameCount}`);
+            }
+            if (errors.length > 0) {
+                await rm(outputPath, { force: true });
+                throw new Error(`change_video_speed produced invalid output for ${assetId}: ${errors.join("; ")}`);
+            }
+            const inputFilename = basename(inputPath);
+            await replaceArtifactFileFromPath(engine, assetId, inputFilename, outputPath);
+            const videoPath = join(assetDir, inputFilename);
+            return { videoPath };
+        }, { durationMs: LOCK_DURATION_MS, waitForActiveMs: 30_000 });
+        await queue.enqueue(`process-video-${assetId}-${Date.now()}`, {
+            type: "process_video",
+            videoPath: result.videoPath,
+            assetId,
+            assetDir,
+            bookId,
+            provenance: {
+                origin: "speed_change",
+                source_asset_id: assetId,
+                speed,
+                targetDuration,
+                speed_changed_at: new Date().toISOString(),
+            },
+            force: true,
+            skipDownstreamJobs: true,
+        });
+        return { success: true };
+    });
+}