@frkntmbs/strapi-plugin-video-optimizer 1.0.0

package/dist/server/index.mjs

@@ -0,0 +1,1533 @@
+import { AsyncLocalStorage } from "async_hooks";
+import fs from "fs";
+import { execSync } from "child_process";
+import path, { join } from "path";
+import { tmpdir } from "os";
+import { randomUUID } from "crypto";
+import ffmpeg from "fluent-ffmpeg";
+import ffmpegStatic from "ffmpeg-static";
+import { file } from "@strapi/utils";
+const PLUGIN_ID = "video-optimizer";
+const OPTIMIZATION_CHOICES = ["original", "global", "custom"];
+const VIDEO_FORMATS = ["mp4", "webm"];
+const VIDEO_CODECS = ["h264", "vp9"];
+const AUDIO_MODES = ["keep", "remove", "compress"];
+const FFMPEG_PRESETS = [
+  "ultrafast",
+  "superfast",
+  "veryfast",
+  "faster",
+  "fast",
+  "medium",
+  "slow",
+  "slower",
+  "veryslow"
+];
+const MAX_CONCURRENT_JOBS_LIMIT = 32;
+const MAX_FFMPEG_THREADS_LIMIT = 8;
+const clampMaxConcurrentJobs = (value) => Math.min(MAX_CONCURRENT_JOBS_LIMIT, Math.max(1, Math.round(value)));
+const clampMaxFfmpegThreads = (value) => Math.min(MAX_FFMPEG_THREADS_LIMIT, Math.max(1, Math.round(value)));
+const isVideoMime = (mime) => typeof mime === "string" && mime.startsWith("video/");
+const codecForFormat = (format) => format === "webm" ? "vp9" : "h264";
+const formatForCodec = (codec) => codec === "vp9" ? "webm" : "mp4";
+const register = async ({ strapi }) => {
+  await strapi.admin.services.permission.actionProvider.registerMany([
+    {
+      section: "plugins",
+      displayName: "Read Video Optimizer settings",
+      uid: "settings.read",
+      pluginName: PLUGIN_ID
+    },
+    {
+      section: "plugins",
+      displayName: "Update Video Optimizer settings",
+      uid: "settings.update",
+      pluginName: PLUGIN_ID
+    }
+  ]);
+};
+const SERVER_BUILD_MARKER = "test-8";
+const uploadContext = new AsyncLocalStorage();
+const optimizerUploadContext = new AsyncLocalStorage();
+let fallbackContext = null;
+let batchPreferences = null;
+const registerUploadBatchPreferences = (preferences) => {
+  batchPreferences = preferences;
+};
+const clearUploadBatchPreferences = () => {
+  batchPreferences = null;
+};
+const normalizeFileName = (value) => value.trim().toLowerCase();
+const resolveUploadBatchPreference = (fileName, assetId) => {
+  if (!batchPreferences?.length) {
+    return null;
+  }
+  const normalizedTarget = normalizeFileName(fileName);
+  const match = batchPreferences.find((entry) => {
+    if (assetId && entry.assetId === assetId) {
+      return true;
+    }
+    return normalizeFileName(entry.fileName) === normalizedTarget;
+  });
+  return match?.preference ?? null;
+};
+const createUploadContext = (preferences) => ({
+  preferences,
+  nextIndex: 0
+});
+const setFallbackUploadPreferences = (preferences) => {
+  fallbackContext = createUploadContext(preferences);
+};
+const clearFallbackUploadPreferences = () => {
+  fallbackContext = null;
+};
+const getActivePreferences = () => {
+  const store = optimizerUploadContext.getStore();
+  if (store?.preferences.length) {
+    return store;
+  }
+  return fallbackContext;
+};
+const parseUploadPreferences = (body) => {
+  const raw = body?.videoOptimizerPreferences;
+  if (!raw) {
+    return [];
+  }
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  return Array.isArray(raw) ? raw : [];
+};
+const consumeUploadPreference = (fileName, assetId) => {
+  const batchPreference = resolveUploadBatchPreference(fileName, assetId);
+  if (batchPreference) {
+    return batchPreference;
+  }
+  const store = getActivePreferences();
+  if (!store) {
+    return null;
+  }
+  const matched = store.preferences.find((entry) => {
+    if (assetId && entry.assetId === assetId) {
+      return true;
+    }
+    return normalizeFileName(entry.fileName) === normalizeFileName(fileName);
+  });
+  if (matched) {
+    return matched.preference;
+  }
+  const indexed = store.preferences[store.nextIndex];
+  if (indexed) {
+    store.nextIndex += 1;
+    return indexed.preference;
+  }
+  return null;
+};
+const UPLOAD_ROUTE_SUFFIXES = ["/upload", "/upload/unstable/upload-file"];
+const isUploadRoute = (method, path2) => {
+  if (method.toUpperCase() !== "POST") {
+    return false;
+  }
+  const normalizedPath = path2.replace(/\/+$/, "") || "/";
+  return UPLOAD_ROUTE_SUFFIXES.some(
+    (suffix) => normalizedPath === suffix || normalizedPath.endsWith(suffix)
+  );
+};
+const pendingPreferencesByKey = /* @__PURE__ */ new Map();
+const buildPreferenceKey = (fileName, assetId) => assetId ? `asset:${assetId}` : `file:${fileName}`;
+const stashUploadPreference = (fileName, assetId, preference2) => {
+  pendingPreferencesByKey.set(buildPreferenceKey(fileName, assetId), preference2);
+  if (assetId) {
+    pendingPreferencesByKey.set(buildPreferenceKey(fileName), preference2);
+  }
+  pendingPreferencesByKey.set(`file:${fileName}`, preference2);
+};
+const takePendingPreference = (fileName, assetId) => {
+  const keys = [
+    assetId ? buildPreferenceKey(fileName, assetId) : null,
+    buildPreferenceKey(fileName),
+    `file:${fileName}`
+  ].filter(Boolean);
+  for (const key of keys) {
+    const preference2 = pendingPreferencesByKey.get(key);
+    if (preference2) {
+      pendingPreferencesByKey.delete(key);
+      return preference2;
+    }
+  }
+  return null;
+};
+const isValidChoice$4 = (choice) => typeof choice === "string" && ["original", "global", "custom"].includes(choice);
+const isValidFormat$3 = (format) => typeof format === "string" && VIDEO_FORMATS.includes(format);
+const isValidCodec$3 = (codec) => typeof codec === "string" && VIDEO_CODECS.includes(codec);
+const isValidAudioMode$3 = (mode) => typeof mode === "string" && AUDIO_MODES.includes(mode);
+const isValidPreset$3 = (preset) => typeof preset === "string" && FFMPEG_PRESETS.includes(preset);
+const normalizeCustomSettings = (custom, global) => {
+  if (!custom || typeof custom !== "object") {
+    return void 0;
+  }
+  const value = custom;
+  if (!isValidFormat$3(value.defaultFormat) && !isValidCodec$3(value.videoCodec)) {
+    return void 0;
+  }
+  const defaultFormat = isValidFormat$3(value.defaultFormat) ? value.defaultFormat : isValidCodec$3(value.videoCodec) ? formatForCodec(value.videoCodec) : global.defaultFormat;
+  return {
+    defaultFormat,
+    videoCodec: isValidCodec$3(value.videoCodec) ? value.videoCodec : codecForFormat(defaultFormat),
+    crf: typeof value.crf === "number" ? value.crf : Number(value.crf ?? global.crf),
+    preset: isValidPreset$3(value.preset) ? value.preset : global.preset,
+    maxWidth: typeof value.maxWidth === "number" && value.maxWidth >= 1 ? value.maxWidth : global.maxWidth,
+    maxHeight: typeof value.maxHeight === "number" && value.maxHeight >= 1 ? value.maxHeight : global.maxHeight,
+    audioMode: isValidAudioMode$3(value.audioMode) ? value.audioMode : global.audioMode,
+    audioBitrate: typeof value.audioBitrate === "string" ? value.audioBitrate : String(value.audioBitrate ?? global.audioBitrate)
+  };
+};
+const configToSettings = (config2) => ({
+  defaultFormat: config2.defaultFormat,
+  videoCodec: config2.videoCodec,
+  crf: config2.crf,
+  preset: config2.preset,
+  maxWidth: config2.maxWidth,
+  maxHeight: config2.maxHeight,
+  audioMode: config2.audioMode,
+  audioBitrate: config2.audioBitrate
+});
+const runWithUser = (userId, fn) => {
+  if (userId === void 0) {
+    return fn();
+  }
+  return uploadContext.run({ userId }, fn);
+};
+const applyPreferenceToEntity = (entity, fileInfo, mime, globalDefaults) => {
+  if (!isVideoMime(mime)) {
+    const batchPreference = resolveUploadBatchPreference(
+      String(entity.name ?? fileInfo.name ?? ""),
+      typeof fileInfo.optimizerAssetId === "string" ? fileInfo.optimizerAssetId : void 0
+    );
+    if (!batchPreference) {
+      return;
+    }
+  }
+  const fileName = String(entity.name ?? fileInfo.name ?? "");
+  const assetId = typeof fileInfo.optimizerAssetId === "string" ? fileInfo.optimizerAssetId : void 0;
+  const preference2 = consumeUploadPreference(fileName, assetId);
+  const applyPreference = (choice, custom) => {
+    entity.optimizationChoice = choice;
+    const normalizedCustom = choice === "custom" ? normalizeCustomSettings(custom, globalDefaults) : void 0;
+    if (normalizedCustom) {
+      entity.optimizationCustom = normalizedCustom;
+    } else {
+      delete entity.optimizationCustom;
+    }
+    if (assetId) {
+      entity.optimizerAssetId = assetId;
+    }
+    stashUploadPreference(fileName, assetId, { choice, custom: normalizedCustom });
+  };
+  if (preference2) {
+    applyPreference(preference2.choice, preference2.custom);
+    return;
+  }
+  if (fileInfo.optimizationChoice && isValidChoice$4(fileInfo.optimizationChoice)) {
+    applyPreference(fileInfo.optimizationChoice, fileInfo.optimizationCustom);
+  }
+};
+const enqueueVideoJobs = async (strapi, files, globalDefaults) => {
+  const preferenceService = strapi.plugin(PLUGIN_ID).service("preference");
+  const jobQueue2 = strapi.plugin(PLUGIN_ID).service("job-queue");
+  try {
+    for (const file2 of files) {
+      if (!isVideoMime(file2.mime)) {
+        continue;
+      }
+      const fileName = String(file2.name ?? "");
+      const assetId = typeof file2.optimizerAssetId === "string" ? file2.optimizerAssetId : void 0;
+      const batchPreference = resolveUploadBatchPreference(fileName, assetId);
+      const pending = takePendingPreference(fileName, assetId);
+      const optimizationChoice = batchPreference?.choice ?? pending?.choice ?? (isValidChoice$4(file2.optimizationChoice) ? file2.optimizationChoice : void 0);
+      const optimizationCustom = (batchPreference?.choice === "custom" ? normalizeCustomSettings(batchPreference.custom, globalDefaults) : void 0) ?? pending?.custom ?? file2.optimizationCustom;
+      const resolved = await preferenceService.resolveOptimization({
+        optimizationChoice,
+        optimizationCustom,
+        mime: file2.mime
+      });
+      if (resolved.skip || !resolved.settings || !file2.id) {
+        strapi.log.debug(
+          `[video-optimizer] Skipping file ${file2.id} (${fileName}): choice=${optimizationChoice ?? "default"}, skip=${resolved.skip}`
+        );
+        continue;
+      }
+      strapi.log.info(
+        `[video-optimizer] Queueing optimization for file ${file2.id} (${fileName}) choice=${optimizationChoice ?? "default"} → ${resolved.settings.defaultFormat}`
+      );
+      await jobQueue2.enqueue({
+        fileId: Number(file2.id),
+        settings: resolved.settings,
+        choice: optimizationChoice
+      });
+    }
+  } finally {
+    clearUploadBatchPreferences();
+  }
+};
+const wrapUploadController = (strapi, handler) => {
+  return async (ctx) => {
+    const preferences = parseUploadPreferences(ctx.request.body);
+    if (preferences.length === 0) {
+      return handler(ctx);
+    }
+    registerUploadBatchPreferences(preferences);
+    strapi.log.info(
+      `[video-optimizer] Controller preferences (${preferences.length}, ${SERVER_BUILD_MARKER}): ${preferences.map((entry) => {
+        const format = entry.preference.choice === "custom" ? entry.preference.custom?.defaultFormat ?? "?" : entry.preference.choice;
+        return `${entry.fileName}=${format}`;
+      }).join(", ")}`
+    );
+    return optimizerUploadContext.run(createUploadContext(preferences), () => handler(ctx));
+  };
+};
+const bootstrap = async ({ strapi }) => {
+  const uploadService = strapi.plugin("upload").service("upload");
+  const globalDefaults = configToSettings(strapi.plugin(PLUGIN_ID).config);
+  strapi.log.info(`[video-optimizer] Server bootstrap loaded (${SERVER_BUILD_MARKER})`);
+  const adminUploadController = strapi.plugin("upload").controllers["admin-upload"];
+  if (adminUploadController?.uploadFiles) {
+    const originalUploadFiles = adminUploadController.uploadFiles.bind(adminUploadController);
+    adminUploadController.uploadFiles = wrapUploadController(strapi, originalUploadFiles);
+  }
+  if (adminUploadController?.unstable_uploadFile) {
+    const originalUnstableUpload = adminUploadController.unstable_uploadFile.bind(adminUploadController);
+    adminUploadController.unstable_uploadFile = wrapUploadController(strapi, originalUnstableUpload);
+  }
+  strapi.server.use(async (ctx, next) => {
+    if (!isUploadRoute(ctx.method, ctx.path)) {
+      return next();
+    }
+    const preferences = parseUploadPreferences(ctx.request.body);
+    if (preferences.length === 0) {
+      return next();
+    }
+    registerUploadBatchPreferences(preferences);
+    strapi.log.debug(
+      `[video-optimizer] Upload preferences received (${preferences.length} file(s)) on ${ctx.path}: ${preferences.map((entry) => {
+        const format = entry.preference.choice === "custom" ? entry.preference.custom?.defaultFormat ?? "?" : entry.preference.choice;
+        return `${entry.fileName}=${format}`;
+      }).join(", ")}`
+    );
+    setFallbackUploadPreferences(preferences);
+    try {
+      return await optimizerUploadContext.run(createUploadContext(preferences), () => next());
+    } finally {
+      clearFallbackUploadPreferences();
+    }
+  });
+  const originalFormatFileInfo = uploadService.formatFileInfo.bind(uploadService);
+  uploadService.formatFileInfo = async (fileProps, fileInfo = {}, metas = {}) => {
+    const entity = await originalFormatFileInfo(fileProps, fileInfo, metas);
+    applyPreferenceToEntity(entity, fileInfo, fileProps.type, globalDefaults);
+    return entity;
+  };
+  const originalUpload = uploadService.upload.bind(uploadService);
+  uploadService.upload = async (args, opts) => {
+    const result = await runWithUser(opts?.user?.id, () => originalUpload(args, opts));
+    const files = Array.isArray(result) ? result : [result];
+    if (files.length) {
+      setImmediate(() => {
+        void enqueueVideoJobs(strapi, files, globalDefaults).catch(
+          (error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            strapi.log.error(`[video-optimizer] Failed to enqueue upload jobs: ${message}`);
+          }
+        );
+      });
+    }
+    return result;
+  };
+  const originalReplace = uploadService.replace.bind(uploadService);
+  uploadService.replace = async (id, args, opts) => {
+    const result = await runWithUser(opts?.user?.id, () => originalReplace(id, args, opts));
+    const files = Array.isArray(result) ? result : [result];
+    if (files.length) {
+      setImmediate(() => {
+        void enqueueVideoJobs(strapi, files, globalDefaults).catch(
+          (error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            strapi.log.error(`[video-optimizer] Failed to enqueue replace jobs: ${message}`);
+          }
+        );
+      });
+    }
+    return result;
+  };
+  const jobQueue2 = strapi.plugin(PLUGIN_ID).service("job-queue");
+  const originalRemove = uploadService.remove.bind(uploadService);
+  uploadService.remove = async (file2) => {
+    await jobQueue2.cancelJobsForFile(Number(file2.id));
+    return originalRemove(file2);
+  };
+  strapi.eventHub.on("media.delete", ({ media }) => {
+    const fileId = Number(media?.id);
+    if (!Number.isFinite(fileId) || fileId <= 0) {
+      return;
+    }
+    void jobQueue2.cancelJobsForFile(fileId);
+  });
+  await strapi.plugin(PLUGIN_ID).service("preference").ensureGlobalSettingsDefaults();
+  await jobQueue2.clearJobsOnStartup();
+};
+const DEFAULT_PLUGIN_CONFIG = {
+  defaultChoice: "original",
+  defaultFormat: "mp4",
+  videoCodec: "h264",
+  crf: 23,
+  preset: "medium",
+  maxWidth: 1920,
+  maxHeight: 1080,
+  audioMode: "compress",
+  audioBitrate: "128k",
+  maxConcurrentJobs: 1,
+  maxFfmpegThreads: 2
+};
+const isValidChoice$3 = (choice) => typeof choice === "string" && OPTIMIZATION_CHOICES.includes(choice);
+const isValidFormat$2 = (format) => typeof format === "string" && VIDEO_FORMATS.includes(format);
+const isValidCodec$2 = (codec) => typeof codec === "string" && VIDEO_CODECS.includes(codec);
+const isValidAudioMode$2 = (mode) => typeof mode === "string" && AUDIO_MODES.includes(mode);
+const isValidPreset$2 = (preset) => typeof preset === "string" && FFMPEG_PRESETS.includes(preset);
+const normalizePluginConfig = (...sources) => {
+  const merged = Object.assign({}, DEFAULT_PLUGIN_CONFIG, ...sources.filter(Boolean));
+  const defaultFormat = isValidFormat$2(merged.defaultFormat) ? merged.defaultFormat : DEFAULT_PLUGIN_CONFIG.defaultFormat;
+  return {
+    defaultChoice: isValidChoice$3(merged.defaultChoice) ? merged.defaultChoice : DEFAULT_PLUGIN_CONFIG.defaultChoice,
+    defaultFormat,
+    videoCodec: isValidCodec$2(merged.videoCodec) ? merged.videoCodec : codecForFormat(defaultFormat),
+    crf: typeof merged.crf === "number" && merged.crf >= 0 && merged.crf <= 51 ? merged.crf : DEFAULT_PLUGIN_CONFIG.crf,
+    preset: isValidPreset$2(merged.preset) ? merged.preset : DEFAULT_PLUGIN_CONFIG.preset,
+    maxWidth: typeof merged.maxWidth === "number" && merged.maxWidth >= 1 ? merged.maxWidth : DEFAULT_PLUGIN_CONFIG.maxWidth,
+    maxHeight: typeof merged.maxHeight === "number" && merged.maxHeight >= 1 ? merged.maxHeight : DEFAULT_PLUGIN_CONFIG.maxHeight,
+    audioMode: isValidAudioMode$2(merged.audioMode) ? merged.audioMode : DEFAULT_PLUGIN_CONFIG.audioMode,
+    audioBitrate: typeof merged.audioBitrate === "string" && merged.audioBitrate.trim() ? merged.audioBitrate : DEFAULT_PLUGIN_CONFIG.audioBitrate,
+    maxConcurrentJobs: clampMaxConcurrentJobs(
+      merged.maxConcurrentJobs ?? DEFAULT_PLUGIN_CONFIG.maxConcurrentJobs
+    ),
+    maxFfmpegThreads: clampMaxFfmpegThreads(
+      merged.maxFfmpegThreads ?? DEFAULT_PLUGIN_CONFIG.maxFfmpegThreads
+    )
+  };
+};
+const config = {
+  default: () => ({ ...DEFAULT_PLUGIN_CONFIG }),
+  validator(config2) {
+    if (config2.crf !== void 0 && (config2.crf < 0 || config2.crf > 51)) {
+      throw new Error("crf must be between 0 and 51");
+    }
+    if (config2.maxWidth !== void 0 && config2.maxWidth < 1) {
+      throw new Error("maxWidth must be at least 1");
+    }
+    if (config2.maxHeight !== void 0 && config2.maxHeight < 1) {
+      throw new Error("maxHeight must be at least 1");
+    }
+    if (config2.maxConcurrentJobs !== void 0 && clampMaxConcurrentJobs(config2.maxConcurrentJobs) !== config2.maxConcurrentJobs) {
+      throw new Error(`maxConcurrentJobs must be between 1 and ${MAX_CONCURRENT_JOBS_LIMIT}`);
+    }
+    if (config2.maxFfmpegThreads !== void 0 && clampMaxFfmpegThreads(config2.maxFfmpegThreads) !== config2.maxFfmpegThreads) {
+      throw new Error(`maxFfmpegThreads must be between 1 and ${MAX_FFMPEG_THREADS_LIMIT}`);
+    }
+  }
+};
+const isValidChoice$2 = (choice) => typeof choice === "string" && OPTIMIZATION_CHOICES.includes(choice);
+const isValidFormat$1 = (format) => typeof format === "string" && VIDEO_FORMATS.includes(format);
+const isValidCodec$1 = (codec) => typeof codec === "string" && VIDEO_CODECS.includes(codec);
+const isValidAudioMode$1 = (mode) => typeof mode === "string" && AUDIO_MODES.includes(mode);
+const isValidPreset$1 = (preset) => typeof preset === "string" && FFMPEG_PRESETS.includes(preset);
+const preference$1 = ({ strapi }) => ({
+  async getDefaultMode(ctx) {
+    const settings = await strapi.plugin("video-optimizer").service("preference").getGlobalSettings();
+    ctx.body = {
+      defaultChoice: settings.defaultChoice,
+      defaultFormat: settings.defaultFormat,
+      videoCodec: settings.videoCodec,
+      crf: settings.crf,
+      preset: settings.preset,
+      maxWidth: settings.maxWidth,
+      maxHeight: settings.maxHeight,
+      audioMode: settings.audioMode,
+      audioBitrate: settings.audioBitrate,
+      maxConcurrentJobs: settings.maxConcurrentJobs,
+      maxFfmpegThreads: settings.maxFfmpegThreads
+    };
+  },
+  async getPreference(ctx) {
+    const userId = ctx.state.user?.id;
+    if (!userId) {
+      return ctx.unauthorized();
+    }
+    const preferenceService = strapi.plugin("video-optimizer").service("preference");
+    const defaultFormat = await preferenceService.getUserPreference(userId);
+    const settings = await preferenceService.getGlobalSettings();
+    ctx.body = {
+      defaultFormat: defaultFormat ?? settings.defaultFormat,
+      defaultChoice: settings.defaultChoice
+    };
+  },
+  async updatePreference(ctx) {
+    const userId = ctx.state.user?.id;
+    if (!userId) {
+      return ctx.unauthorized();
+    }
+    const { defaultFormat } = ctx.request.body ?? {};
+    if (!isValidFormat$1(defaultFormat)) {
+      return ctx.badRequest("Invalid video format");
+    }
+    await strapi.plugin("video-optimizer").service("preference").setUserPreference(userId, defaultFormat);
+    ctx.body = { defaultFormat };
+  },
+  async getSettings(ctx) {
+    const settings = await strapi.plugin("video-optimizer").service("preference").getGlobalSettings();
+    ctx.body = settings;
+  },
+  async updateSettings(ctx) {
+    const {
+      defaultChoice,
+      defaultFormat,
+      videoCodec,
+      crf,
+      preset,
+      maxWidth,
+      maxHeight,
+      audioMode,
+      audioBitrate,
+      maxConcurrentJobs,
+      maxFfmpegThreads
+    } = ctx.request.body ?? {};
+    if (defaultChoice !== void 0 && !isValidChoice$2(defaultChoice)) {
+      return ctx.badRequest("Invalid default choice");
+    }
+    if (defaultFormat !== void 0 && !isValidFormat$1(defaultFormat)) {
+      return ctx.badRequest("Invalid default format");
+    }
+    if (videoCodec !== void 0 && !isValidCodec$1(videoCodec)) {
+      return ctx.badRequest("Invalid video codec");
+    }
+    if (crf !== void 0 && (crf < 0 || crf > 51)) {
+      return ctx.badRequest("Invalid CRF value");
+    }
+    if (preset !== void 0 && !isValidPreset$1(preset)) {
+      return ctx.badRequest("Invalid preset");
+    }
+    if (maxWidth !== void 0 && maxWidth < 1) {
+      return ctx.badRequest("Invalid max width");
+    }
+    if (maxHeight !== void 0 && maxHeight < 1) {
+      return ctx.badRequest("Invalid max height");
+    }
+    if (audioMode !== void 0 && !isValidAudioMode$1(audioMode)) {
+      return ctx.badRequest("Invalid audio mode");
+    }
+    if (maxConcurrentJobs !== void 0 && clampMaxConcurrentJobs(Number(maxConcurrentJobs)) !== Number(maxConcurrentJobs)) {
+      return ctx.badRequest(`maxConcurrentJobs must be between 1 and ${MAX_CONCURRENT_JOBS_LIMIT}`);
+    }
+    if (maxFfmpegThreads !== void 0 && clampMaxFfmpegThreads(Number(maxFfmpegThreads)) !== Number(maxFfmpegThreads)) {
+      return ctx.badRequest(`maxFfmpegThreads must be between 1 and ${MAX_FFMPEG_THREADS_LIMIT}`);
+    }
+    const payload = {};
+    if (defaultChoice !== void 0) payload.defaultChoice = defaultChoice;
+    if (defaultFormat !== void 0) {
+      payload.defaultFormat = defaultFormat;
+      if (videoCodec === void 0) {
+        payload.videoCodec = codecForFormat(defaultFormat);
+      }
+    }
+    if (videoCodec !== void 0) payload.videoCodec = videoCodec;
+    if (crf !== void 0) payload.crf = Number(crf);
+    if (preset !== void 0) payload.preset = preset;
+    if (maxWidth !== void 0) payload.maxWidth = Number(maxWidth);
+    if (maxHeight !== void 0) payload.maxHeight = Number(maxHeight);
+    if (audioMode !== void 0) payload.audioMode = audioMode;
+    if (audioBitrate !== void 0) payload.audioBitrate = String(audioBitrate);
+    if (maxConcurrentJobs !== void 0) payload.maxConcurrentJobs = Number(maxConcurrentJobs);
+    if (maxFfmpegThreads !== void 0) payload.maxFfmpegThreads = Number(maxFfmpegThreads);
+    await strapi.plugin("video-optimizer").service("preference").setGlobalSettings(payload);
+    if (maxConcurrentJobs !== void 0) {
+      void strapi.plugin("video-optimizer").service("job-queue").drainQueue();
+    }
+    const settings = await strapi.plugin("video-optimizer").service("preference").getGlobalSettings();
+    ctx.body = settings;
+  }
+});
+const isValidChoice$1 = (choice) => typeof choice === "string" && OPTIMIZATION_CHOICES.includes(choice);
+const job = ({ strapi }) => ({
+  async getJob(ctx) {
+    const { id } = ctx.params;
+    const job2 = await strapi.plugin("video-optimizer").service("job-queue").getJob(id);
+    if (!job2) {
+      return ctx.notFound("Job not found");
+    }
+    ctx.body = job2;
+  },
+  async getJobsByFiles(ctx) {
+    const raw = ctx.query.fileIds;
+    if (!raw || typeof raw !== "string") {
+      return ctx.badRequest("fileIds query parameter is required");
+    }
+    const fileIds = raw.split(",").map((value) => Number(value.trim())).filter((value) => Number.isFinite(value) && value > 0);
+    const jobs = await strapi.plugin("video-optimizer").service("job-queue").getJobsByFileIds(fileIds);
+    ctx.body = { jobs };
+  },
+  async listActive(ctx) {
+    const jobs = await strapi.plugin("video-optimizer").service("job-queue").listActiveJobs();
+    ctx.body = { jobs };
+  },
+  async enqueueFile(ctx) {
+    const body = ctx.request.body;
+    const fileId = Number(body.fileId);
+    if (!Number.isFinite(fileId) || fileId <= 0) {
+      return ctx.badRequest("fileId is required");
+    }
+    const file2 = await strapi.db.query("plugin::upload.file").findOne({
+      where: { id: fileId }
+    });
+    if (!file2) {
+      return ctx.notFound("File not found");
+    }
+    if (!file2.mime || !String(file2.mime).startsWith("video/")) {
+      return ctx.badRequest("Only video files can be optimized");
+    }
+    const preferenceService = strapi.plugin("video-optimizer").service("preference");
+    const resolved = await preferenceService.resolveOptimization({
+      optimizationChoice: isValidChoice$1(body.optimizationChoice) ? body.optimizationChoice : void 0,
+      optimizationCustom: body.optimizationCustom,
+      mime: String(file2.mime)
+    });
+    if (resolved.skip || !resolved.settings) {
+      return ctx.badRequest("Optimization is disabled for the selected choice");
+    }
+    const job2 = await strapi.plugin("video-optimizer").service("job-queue").enqueue({
+      fileId,
+      settings: resolved.settings,
+      choice: isValidChoice$1(body.optimizationChoice) ? body.optimizationChoice : void 0
+    });
+    ctx.body = { job: job2 };
+  },
+  async cancelForFile(ctx) {
+    const body = ctx.request.body;
+    const fileId = Number(body.fileId);
+    if (!Number.isFinite(fileId) || fileId <= 0) {
+      return ctx.badRequest("fileId is required");
+    }
+    await strapi.plugin("video-optimizer").service("job-queue").cancelJobsForFile(fileId);
+    ctx.body = { ok: true };
+  }
+});
+const controllers = {
+  preference: preference$1,
+  job
+};
+const routes = {
+  admin: {
+    type: "admin",
+    routes: [
+      {
+        method: "GET",
+        path: "/default-mode",
+        handler: "preference.getDefaultMode",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"]
+        }
+      },
+      {
+        method: "GET",
+        path: "/preference",
+        handler: "preference.getPreference",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"]
+        }
+      },
+      {
+        method: "PUT",
+        path: "/preference",
+        handler: "preference.updatePreference",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"]
+        }
+      },
+      {
+        method: "GET",
+        path: "/settings",
+        handler: "preference.getSettings",
+        config: {
+          policies: [
+            "admin::isAuthenticatedAdmin",
+            {
+              name: "admin::hasPermissions",
+              config: {
+                actions: ["plugin::video-optimizer.settings.read"]
+              }
+            }
+          ]
+        }
+      },
+      {
+        method: "PUT",
+        path: "/settings",
+        handler: "preference.updateSettings",
+        config: {
+          policies: [
+            "admin::isAuthenticatedAdmin",
+            {
+              name: "admin::hasPermissions",
+              config: {
+                actions: ["plugin::video-optimizer.settings.update"]
+              }
+            }
+          ]
+        }
+      },
+      {
+        method: "GET",
+        path: "/jobs/active",
+        handler: "job.listActive",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"]
+        }
+      },
+      {
+        method: "GET",
+        path: "/jobs/by-files",
+        handler: "job.getJobsByFiles",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"]
+        }
+      },
+      {
+        method: "POST",
+        path: "/jobs/enqueue",
+        handler: "job.enqueueFile",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"]
+        }
+      },
+      {
+        method: "POST",
+        path: "/jobs/cancel",
+        handler: "job.cancelForFile",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"]
+        }
+      },
+      {
+        method: "GET",
+        path: "/jobs/:id",
+        handler: "job.getJob",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"]
+        }
+      }
+    ]
+  }
+};
+const GLOBAL_SETTINGS_KEY = "global-settings";
+const JOBS_STORE_KEY = "jobs";
+const userPreferenceKey = (userId) => `user-pref-${userId}`;
+const isValidChoice = (choice) => typeof choice === "string" && OPTIMIZATION_CHOICES.includes(choice);
+const isValidFormat = (format) => typeof format === "string" && VIDEO_FORMATS.includes(format);
+const isValidCodec = (codec) => typeof codec === "string" && VIDEO_CODECS.includes(codec);
+const isValidAudioMode = (mode) => typeof mode === "string" && AUDIO_MODES.includes(mode);
+const isValidPreset = (preset) => typeof preset === "string" && FFMPEG_PRESETS.includes(preset);
+const buildSettings = (source) => {
+  const defaultFormat = isValidFormat(source.defaultFormat) ? source.defaultFormat : "mp4";
+  const videoCodec = isValidCodec(source.videoCodec) ? source.videoCodec : codecForFormat(defaultFormat);
+  return {
+    defaultFormat,
+    videoCodec,
+    crf: source.crf ?? 23,
+    preset: isValidPreset(source.preset) ? source.preset : "medium",
+    maxWidth: source.maxWidth ?? 1920,
+    maxHeight: source.maxHeight ?? 1080,
+    audioMode: isValidAudioMode(source.audioMode) ? source.audioMode : "compress",
+    audioBitrate: source.audioBitrate ?? "128k"
+  };
+};
+const preference = ({ strapi }) => ({
+  async getUserPreference(userId) {
+    const stored = await strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID,
+      key: userPreferenceKey(userId)
+    }).get();
+    if (stored?.defaultFormat && isValidFormat(stored.defaultFormat)) {
+      return stored.defaultFormat;
+    }
+    return null;
+  },
+  async setUserPreference(userId, defaultFormat) {
+    await strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID,
+      key: userPreferenceKey(userId)
+    }).set({ value: { defaultFormat } });
+  },
+  async getGlobalSettings() {
+    const pluginConfig = strapi.plugin(PLUGIN_ID).config;
+    const stored = await strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID,
+      key: GLOBAL_SETTINGS_KEY
+    }).get();
+    return normalizePluginConfig(DEFAULT_PLUGIN_CONFIG, pluginConfig, stored ?? void 0);
+  },
+  async ensureGlobalSettingsDefaults() {
+    const store = strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID,
+      key: GLOBAL_SETTINGS_KEY
+    });
+    const stored = await store.get();
+    if (!stored || Object.keys(stored).length === 0) {
+      const pluginConfig = strapi.plugin(PLUGIN_ID).config;
+      const defaults = normalizePluginConfig(DEFAULT_PLUGIN_CONFIG, pluginConfig);
+      await store.set({ value: defaults });
+    }
+  },
+  async setGlobalSettings(settings) {
+    const current = await this.getGlobalSettings();
+    const next = { ...current, ...settings };
+    await strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID,
+      key: GLOBAL_SETTINGS_KEY
+    }).set({ value: next });
+  },
+  async resolveOptimization(file2) {
+    const global = await this.getGlobalSettings();
+    if (!file2.mime || !file2.mime.startsWith("video/")) {
+      return { skip: true };
+    }
+    const choice = isValidChoice(file2.optimizationChoice) ? file2.optimizationChoice : global.defaultChoice;
+    if (choice === "original") {
+      return { skip: true };
+    }
+    if (choice === "global") {
+      return {
+        skip: false,
+        settings: buildSettings(global)
+      };
+    }
+    const custom = file2.optimizationCustom ?? {};
+    return {
+      skip: false,
+      settings: buildSettings({
+        defaultFormat: custom.defaultFormat ?? global.defaultFormat,
+        videoCodec: custom.videoCodec ?? global.videoCodec,
+        crf: custom.crf ?? global.crf,
+        preset: custom.preset ?? global.preset,
+        maxWidth: custom.maxWidth ?? global.maxWidth,
+        maxHeight: custom.maxHeight ?? global.maxHeight,
+        audioMode: custom.audioMode ?? global.audioMode,
+        audioBitrate: custom.audioBitrate ?? global.audioBitrate
+      })
+    };
+  },
+  getJobsStore() {
+    return strapi.store({
+      type: "plugin",
+      name: PLUGIN_ID,
+      key: JOBS_STORE_KEY
+    });
+  }
+});
+const { bytesToKbytes } = file;
+let ffmpegPathConfigured = false;
+const activeCommands = /* @__PURE__ */ new Map();
+const configureFfmpegPath = () => {
+  if (ffmpegPathConfigured) {
+    return;
+  }
+  if (ffmpegStatic) {
+    ffmpeg.setFfmpegPath(ffmpegStatic);
+    ffmpegPathConfigured = true;
+    return;
+  }
+  try {
+    const systemPath = execSync("which ffmpeg", { encoding: "utf8" }).trim();
+    if (systemPath) {
+      ffmpeg.setFfmpegPath(systemPath);
+      ffmpegPathConfigured = true;
+    }
+  } catch {
+  }
+};
+const probeVideo = (inputPath) => new Promise((resolve, reject) => {
+  ffmpeg.ffprobe(inputPath, (error, metadata) => {
+    if (error) {
+      reject(error);
+      return;
+    }
+    const videoStream = metadata.streams.find((stream) => stream.codec_type === "video");
+    resolve({
+      width: videoStream?.width ?? void 0,
+      height: videoStream?.height ?? void 0,
+      duration: metadata.format.duration ?? void 0
+    });
+  });
+});
+const buildScaleFilter = (settings, metadata, resizeMode = "exact") => {
+  const targetWidth = settings.maxWidth;
+  const targetHeight = settings.maxHeight;
+  const sourceWidth = metadata.width ?? 0;
+  const sourceHeight = metadata.height ?? 0;
+  if (!targetWidth || !targetHeight || !sourceWidth || !sourceHeight) {
+    return null;
+  }
+  if (targetWidth === sourceWidth && targetHeight === sourceHeight) {
+    return null;
+  }
+  if (resizeMode === "fit-within") {
+    if (sourceWidth <= targetWidth && sourceHeight <= targetHeight) {
+      return null;
+    }
+    return `scale='min(${targetWidth},iw)':'min(${targetHeight},ih)':force_original_aspect_ratio=decrease`;
+  }
+  return `scale=${targetWidth}:${targetHeight}`;
+};
+const buildVideoCodecOptions = (settings, maxThreads) => {
+  if (settings.defaultFormat === "webm" || settings.videoCodec === "vp9") {
+    return {
+      videoCodec: "libvpx-vp9",
+      outputOptions: [
+        "-crf",
+        String(settings.crf),
+        "-b:v",
+        "0",
+        "-row-mt",
+        maxThreads > 1 ? "1" : "0",
+        "-speed",
+        "4"
+      ]
+    };
+  }
+  return {
+    videoCodec: "libx264",
+    outputOptions: [`-crf`, String(settings.crf), "-preset", settings.preset]
+  };
+};
+const buildThreadOptions = (maxThreads) => {
+  const threads = clampMaxFfmpegThreads(maxThreads);
+  return ["-threads", String(threads)];
+};
+const buildAudioOptions = (settings) => {
+  if (settings.audioMode === "remove") {
+    return { audioCodec: void 0, outputOptions: ["-an"] };
+  }
+  if (settings.audioMode === "compress") {
+    const codec = settings.defaultFormat === "webm" ? "libopus" : "aac";
+    return {
+      audioCodec: codec,
+      outputOptions: ["-b:a", settings.audioBitrate]
+    };
+  }
+  return { audioCodec: void 0, outputOptions: [] };
+};
+const optimizer = ({ strapi }) => ({
+  cancel(jobId) {
+    const active = activeCommands.get(jobId);
+    if (!active) {
+      return false;
+    }
+    try {
+      active.command.kill("SIGKILL");
+    } catch {
+    }
+    try {
+      if (fs.existsSync(active.outputPath)) {
+        fs.unlinkSync(active.outputPath);
+      }
+    } catch {
+    }
+    activeCommands.delete(jobId);
+    return true;
+  },
+  async process({
+    jobId,
+    inputPath,
+    settings,
+    resizeMode = "exact",
+    onProgress
+  }) {
+    configureFfmpegPath();
+    const metadata = await probeVideo(inputPath);
+    const outputExt = settings.defaultFormat === "webm" ? ".webm" : ".mp4";
+    const outputMime = settings.defaultFormat === "webm" ? "video/webm" : "video/mp4";
+    const outputPath = join(tmpdir(), `video-optimizer-${randomUUID()}${outputExt}`);
+    const scaleFilter = buildScaleFilter(settings, metadata, resizeMode);
+    const globalSettings = await strapi.plugin("video-optimizer").service("preference").getGlobalSettings();
+    const maxThreads = globalSettings.maxFfmpegThreads;
+    const videoOptions = buildVideoCodecOptions(settings, maxThreads);
+    const audioOptions = buildAudioOptions(settings);
+    const threadOptions = buildThreadOptions(maxThreads);
+    const duration = metadata.duration ?? 0;
+    await new Promise((resolve, reject) => {
+      let command = ffmpeg(inputPath);
+      if (scaleFilter) {
+        command = command.videoFilters(scaleFilter);
+      }
+      command = command.format(settings.defaultFormat).videoCodec(videoOptions.videoCodec).outputOptions([
+        ...threadOptions,
+        ...videoOptions.outputOptions,
+        ...audioOptions.outputOptions
+      ]);
+      if (audioOptions.audioCodec) {
+        command = command.audioCodec(audioOptions.audioCodec);
+      }
+      activeCommands.set(jobId, { command, outputPath });
+      command.on("start", () => {
+        onProgress?.(5, "encoding");
+      }).on("progress", (progress) => {
+        if (!duration || !progress.timemark) {
+          onProgress?.(50, "encoding");
+          return;
+        }
+        const parts = progress.timemark.split(":").map(Number);
+        const seconds = (parts[0] ?? 0) * 3600 + (parts[1] ?? 0) * 60 + (parts[2] ?? 0);
+        const ratio = Math.min(1, seconds / duration);
+        onProgress?.(Math.round(5 + ratio * 90), "encoding");
+      }).on("end", () => {
+        onProgress?.(98, "finalizing");
+        resolve();
+      }).on("error", (error) => {
+        reject(error);
+      }).save(outputPath);
+    }).finally(() => {
+      activeCommands.delete(jobId);
+    });
+    const outputMetadata = await probeVideo(outputPath);
+    const stats = fs.statSync(outputPath);
+    const baseName = inputPath.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "video";
+    return {
+      outputPath,
+      width: outputMetadata.width,
+      height: outputMetadata.height,
+      sizeInBytes: stats.size,
+      ext: outputExt,
+      mime: outputMime,
+      name: `${baseName}${outputExt}`
+    };
+  },
+  async cleanup(path2) {
+    try {
+      if (fs.existsSync(path2)) {
+        fs.unlinkSync(path2);
+      }
+    } catch {
+    }
+  },
+  bytesToKbytes
+});
+const FILE_MODEL_UID = "plugin::upload.file";
+const emptyStore = () => ({ byId: {}, byFileId: {} });
+const now = () => (/* @__PURE__ */ new Date()).toISOString();
+const jobQueue = ({ strapi }) => {
+  const activeJobs = /* @__PURE__ */ new Set();
+  const cancelledJobIds = /* @__PURE__ */ new Set();
+  let draining = false;
+  const getPreferenceService = () => strapi.plugin(PLUGIN_ID).service("preference");
+  const getOptimizerService = () => strapi.plugin(PLUGIN_ID).service("optimizer");
+  const loadStore = async () => {
+    const stored = await getPreferenceService().getJobsStore().get();
+    return stored ?? emptyStore();
+  };
+  const saveStore = async (store) => {
+    await getPreferenceService().getJobsStore().set({ value: store });
+  };
+  const updateJob = async (jobId, patch) => {
+    const store = await loadStore();
+    const current = store.byId[jobId];
+    if (!current) {
+      return null;
+    }
+    const next = {
+      ...current,
+      ...patch,
+      updatedAt: now()
+    };
+    if (activeJobs.has(jobId) && patch.status !== "completed" && patch.status !== "failed") {
+      next.status = "processing";
+    }
+    store.byId[jobId] = next;
+    await saveStore(store);
+    return next;
+  };
+  const removeStaleJobsForFile = (store, fileId, keepJobId) => {
+    for (const [jobId, job2] of Object.entries(store.byId)) {
+      if (job2.fileId !== fileId) {
+        continue;
+      }
+      if (jobId === keepJobId) {
+        continue;
+      }
+      if (activeJobs.has(jobId)) {
+        continue;
+      }
+      delete store.byId[jobId];
+    }
+  };
+  const isCancellationError = (jobId, error) => {
+    if (cancelledJobIds.has(jobId)) {
+      return true;
+    }
+    if (!(error instanceof Error)) {
+      return false;
+    }
+    return /SIGKILL|SIGTERM|ffmpeg was killed|cancelled|canceled/i.test(error.message);
+  };
+  const cancelJobsForFile = async (fileId) => {
+    const store = await loadStore();
+    const matchingJobs = Object.values(store.byId).filter((job2) => job2.fileId === fileId);
+    if (!matchingJobs.length) {
+      return;
+    }
+    for (const job2 of matchingJobs) {
+      cancelledJobIds.add(job2.id);
+      activeJobs.delete(job2.id);
+      getOptimizerService().cancel(job2.id);
+      delete store.byId[job2.id];
+    }
+    delete store.byFileId[String(fileId)];
+    await saveStore(store);
+    const file2 = await strapi.db.query("plugin::upload.file").findOne({
+      where: { id: fileId }
+    });
+    if (file2) {
+      const providerMetadata = {
+        ...file2.provider_metadata ?? {}
+      };
+      delete providerMetadata.videoOptimizer;
+      await strapi.db.query("plugin::upload.file").update({
+        where: { id: fileId },
+        data: {
+          provider_metadata: providerMetadata
+        }
+      });
+    }
+    strapi.log.info(`[video-optimizer] Cancelled ${matchingJobs.length} job(s) for file ${fileId}`);
+    void drainQueue();
+  };
+  const removeJobFromStore = async (jobId, fileId) => {
+    const store = await loadStore();
+    delete store.byId[jobId];
+    if (fileId !== void 0 && store.byFileId[String(fileId)] === jobId) {
+      delete store.byFileId[String(fileId)];
+    }
+    await saveStore(store);
+  };
+  const getMaxConcurrentJobs = async () => {
+    const settings = await getPreferenceService().getGlobalSettings();
+    return settings.maxConcurrentJobs;
+  };
+  const resolveInputPath = async (fileId) => {
+    const file2 = await strapi.db.query("plugin::upload.file").findOne({
+      where: { id: fileId }
+    });
+    if (!file2?.url) {
+      return null;
+    }
+    const uploadConfig = strapi.config.get("plugin::upload");
+    const provider = uploadConfig?.provider ?? "local";
+    if (provider === "local") {
+      const publicDir = strapi.dirs.static.public;
+      const relativePath = String(file2.url).replace(/^\//, "");
+      const absolutePath = `${publicDir}/${relativePath}`;
+      if (fs.existsSync(absolutePath)) {
+        return absolutePath;
+      }
+    }
+    const uploadFolder = strapi.dirs.static.public;
+    const uploadsPath = `${uploadFolder}/uploads/${file2.hash}${file2.ext}`;
+    if (fs.existsSync(uploadsPath)) {
+      return uploadsPath;
+    }
+    return null;
+  };
+  const applyOptimizedFile = async (fileId, result) => {
+    const file2 = await strapi.db.query("plugin::upload.file").findOne({
+      where: { id: fileId }
+    });
+    if (!file2) {
+      throw new Error(`File ${fileId} not found`);
+    }
+    const publicDir = strapi.dirs.static.public;
+    const oldRelativePath = String(file2.url).replace(/^\//, "");
+    const oldAbsolutePath = path.join(publicDir, oldRelativePath);
+    const baseName = String(file2.name).replace(/\.[^.]+$/, "");
+    const newRelativePath = `/uploads/${file2.hash}${result.ext}`;
+    const newAbsolutePath = path.join(publicDir, newRelativePath.replace(/^\//, ""));
+    const originalSizeInBytes = Number(
+      file2.sizeInBytes ?? (typeof file2.size === "number" ? Math.round(file2.size * 1024) : 0)
+    );
+    if (oldAbsolutePath !== newAbsolutePath && fs.existsSync(oldAbsolutePath)) {
+      fs.unlinkSync(oldAbsolutePath);
+    }
+    fs.mkdirSync(path.dirname(newAbsolutePath), { recursive: true });
+    fs.copyFileSync(result.outputPath, newAbsolutePath);
+    const updatePayload = {
+      name: `${baseName}${result.ext}`,
+      ext: result.ext,
+      mime: result.mime,
+      url: newRelativePath,
+      size: getOptimizerService().bytesToKbytes(result.sizeInBytes),
+      sizeInBytes: result.sizeInBytes,
+      width: result.width ?? file2.width,
+      height: result.height ?? file2.height,
+      provider_metadata: {
+        ...file2.provider_metadata ?? {},
+        videoOptimizer: {
+          status: "completed",
+          optimizedAt: now(),
+          originalSizeInBytes,
+          optimizedSizeInBytes: result.sizeInBytes,
+          format: result.ext.replace(".", "")
+        }
+      }
+    };
+    const updated = await strapi.db.query(FILE_MODEL_UID).update({
+      where: { id: fileId },
+      data: updatePayload
+    });
+    strapi.eventHub.emit("media.update", { media: updated });
+    strapi.log.info(
+      `[video-optimizer] File ${fileId} updated in Media Library (${Math.round(originalSizeInBytes / 1024 / 1024)}MB → ${Math.round(result.sizeInBytes / 1024 / 1024)}MB, ${result.ext})`
+    );
+  };
+  const getTargetExt = (job2) => job2.settings?.defaultFormat === "webm" ? ".webm" : ".mp4";
+  const getOptimizerMeta = (file2) => file2.provider_metadata?.videoOptimizer;
+  const runJob = async (jobId) => {
+    if (!activeJobs.has(jobId)) {
+      activeJobs.add(jobId);
+    }
+    let fileId;
+    try {
+      const store = await loadStore();
+      const job2 = store.byId[jobId];
+      if (!job2) {
+        return;
+      }
+      fileId = job2.fileId;
+      strapi.log.info(`[video-optimizer] Job ${jobId} started for file ${job2.fileId}`);
+      await updateJob(jobId, { status: "processing", stage: "preparing", progress: 0 });
+      const file2 = await strapi.db.query("plugin::upload.file").findOne({
+        where: { id: job2.fileId }
+      });
+      if (!file2) {
+        throw new Error("Uploaded file not found");
+      }
+      const settings = job2.settings;
+      if (!settings) {
+        await updateJob(jobId, {
+          status: "completed",
+          stage: "skipped",
+          progress: 100
+        });
+        return;
+      }
+      const optimizerMeta = getOptimizerMeta(file2);
+      const resizeMode = optimizerMeta?.choice === "global" ? "fit-within" : "exact";
+      const inputPath = await resolveInputPath(job2.fileId);
+      if (!inputPath) {
+        throw new Error("Could not resolve uploaded file path");
+      }
+      strapi.log.info(
+        `[video-optimizer] Job ${jobId} encoding file ${job2.fileId} as ${settings.defaultFormat} (input: ${inputPath})`
+      );
+      let lastLoggedProgress = -1;
+      const result = await getOptimizerService().process({
+        jobId,
+        inputPath,
+        settings,
+        resizeMode,
+        onProgress: (progress, stage) => {
+          void updateJob(jobId, { status: "processing", progress, stage });
+          if (progress >= lastLoggedProgress + 10 || progress >= 95) {
+            lastLoggedProgress = progress;
+            strapi.log.info(
+              `[video-optimizer] Job ${jobId} progress ${progress}% (${stage}, ${settings.defaultFormat})`
+            );
+          }
+        }
+      });
+      await applyOptimizedFile(job2.fileId, result);
+      await getOptimizerService().cleanup(result.outputPath);
+      await updateJob(jobId, {
+        status: "completed",
+        stage: "completed",
+        progress: 100
+      });
+      await removeJobFromStore(jobId, job2.fileId);
+      strapi.log.info(
+        `[video-optimizer] Job ${jobId} completed for file ${job2.fileId} → ${result.ext} (${result.sizeInBytes} bytes)`
+      );
+    } catch (error) {
+      if (isCancellationError(jobId, error)) {
+        cancelledJobIds.delete(jobId);
+        await removeJobFromStore(jobId, fileId);
+        strapi.log.info(
+          `[video-optimizer] Job ${jobId} cancelled${fileId ? ` for file ${fileId}` : ""}`
+        );
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Video optimization failed";
+      await updateJob(jobId, {
+        status: "failed",
+        stage: "failed",
+        progress: 0,
+        error: message
+      });
+      if (fileId) {
+        const file2 = await strapi.db.query("plugin::upload.file").findOne({
+          where: { id: fileId }
+        });
+        if (file2) {
+          await strapi.db.query("plugin::upload.file").update({
+            where: { id: fileId },
+            data: {
+              provider_metadata: {
+                ...file2.provider_metadata ?? {},
+                videoOptimizer: {
+                  status: "failed",
+                  error: message,
+                  failedAt: now()
+                }
+              }
+            }
+          });
+        }
+      }
+      strapi.log.error(`[video-optimizer] Job ${jobId} failed: ${message}`);
+    } finally {
+      activeJobs.delete(jobId);
+      void drainQueue();
+    }
+  };
+  const drainQueue = async () => {
+    if (draining) {
+      return;
+    }
+    draining = true;
+    try {
+      const maxConcurrent = await getMaxConcurrentJobs();
+      const store = await loadStore();
+      const queued = Object.values(store.byId).filter((job2) => job2.status === "queued").sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+      for (const job2 of queued) {
+        if (activeJobs.size >= maxConcurrent) {
+          break;
+        }
+        if (activeJobs.has(job2.id)) {
+          continue;
+        }
+        activeJobs.add(job2.id);
+        void runJob(job2.id);
+      }
+    } finally {
+      draining = false;
+    }
+  };
+  return {
+    async enqueue({ fileId, settings, choice }) {
+      const store = await loadStore();
+      const existingId = store.byFileId[String(fileId)];
+      const existingJob = existingId ? store.byId[existingId] : void 0;
+      if (existingJob?.status === "processing" && activeJobs.has(existingId)) {
+        return existingJob;
+      }
+      removeStaleJobsForFile(store, fileId);
+      const file2 = await strapi.db.query("plugin::upload.file").findOne({
+        where: { id: fileId }
+      });
+      const job2 = {
+        id: randomUUID(),
+        fileId,
+        fileName: file2?.name ? String(file2.name) : void 0,
+        fileHash: file2?.hash ? String(file2.hash) : void 0,
+        status: "queued",
+        stage: "queued",
+        progress: 0,
+        settings,
+        createdAt: now(),
+        updatedAt: now()
+      };
+      store.byId[job2.id] = job2;
+      store.byFileId[String(fileId)] = job2.id;
+      await saveStore(store);
+      strapi.log.info(
+        `[video-optimizer] Job ${job2.id} queued for file ${fileId} (${settings.defaultFormat}, crf=${settings.crf})`
+      );
+      if (file2) {
+        await strapi.db.query("plugin::upload.file").update({
+          where: { id: fileId },
+          data: {
+            provider_metadata: {
+              ...file2.provider_metadata ?? {},
+              videoOptimizer: {
+                status: "queued",
+                jobId: job2.id,
+                queuedAt: now(),
+                ...choice ? { choice } : {}
+              }
+            }
+          }
+        });
+      }
+      void drainQueue();
+      return job2;
+    },
+    async getJob(jobId) {
+      const store = await loadStore();
+      return store.byId[jobId] ?? null;
+    },
+    async getJobsByFileIds(fileIds) {
+      const store = await loadStore();
+      const jobs = [];
+      for (const fileId of fileIds) {
+        const jobId = store.byFileId[String(fileId)];
+        if (jobId && store.byId[jobId]) {
+          jobs.push(store.byId[jobId]);
+        }
+      }
+      return jobs;
+    },
+    async listActiveJobs() {
+      const store = await loadStore();
+      const result = [];
+      let dirty = false;
+      for (const job2 of Object.values(store.byId)) {
+        if (job2.status === "completed" || job2.status === "failed") {
+          delete store.byId[job2.id];
+          if (store.byFileId[String(job2.fileId)] === job2.id) {
+            delete store.byFileId[String(job2.fileId)];
+          }
+          dirty = true;
+        }
+      }
+      for (const job2 of Object.values(store.byId)) {
+        if (job2.status !== "queued" && job2.status !== "processing") {
+          continue;
+        }
+        const canonicalJobId = store.byFileId[String(job2.fileId)];
+        const isRunning = activeJobs.has(job2.id);
+        const isCanonical = canonicalJobId === job2.id;
+        if (!isCanonical && !isRunning) {
+          delete store.byId[job2.id];
+          dirty = true;
+          continue;
+        }
+        if (isRunning && !isCanonical) {
+          store.byFileId[String(job2.fileId)] = job2.id;
+          if (canonicalJobId && canonicalJobId !== job2.id && !activeJobs.has(canonicalJobId)) {
+            delete store.byId[canonicalJobId];
+          }
+          dirty = true;
+        }
+        const file2 = await strapi.db.query("plugin::upload.file").findOne({
+          where: { id: job2.fileId }
+        });
+        if (!file2) {
+          await cancelJobsForFile(job2.fileId);
+          continue;
+        }
+        const optimizerMeta = getOptimizerMeta(file2);
+        if (optimizerMeta?.status === "completed" || optimizerMeta?.status === "failed") {
+          delete store.byId[job2.id];
+          if (store.byFileId[String(job2.fileId)] === job2.id) {
+            delete store.byFileId[String(job2.fileId)];
+          }
+          dirty = true;
+          continue;
+        }
+        let current = store.byId[job2.id] ?? job2;
+        if (!current.fileName && file2.name) {
+          current = {
+            ...current,
+            fileName: String(file2.name),
+            updatedAt: now()
+          };
+          store.byId[job2.id] = current;
+          dirty = true;
+        }
+        if (!current.fileHash && file2.hash) {
+          current = {
+            ...current,
+            fileHash: String(file2.hash),
+            updatedAt: now()
+          };
+          store.byId[job2.id] = current;
+          dirty = true;
+        }
+        if (isRunning && current.status !== "processing") {
+          current = {
+            ...current,
+            status: "processing",
+            updatedAt: now()
+          };
+          store.byId[job2.id] = current;
+          dirty = true;
+        }
+        if (current.status === "processing" && !isRunning) {
+          if (optimizerMeta?.status === "completed" || optimizerMeta?.status === "failed") {
+            delete store.byId[job2.id];
+            if (store.byFileId[String(job2.fileId)] === job2.id) {
+              delete store.byFileId[String(job2.fileId)];
+            }
+            dirty = true;
+            continue;
+          }
+          const targetExt = getTargetExt(current);
+          if (file2.ext === targetExt) {
+            delete store.byId[job2.id];
+            if (store.byFileId[String(job2.fileId)] === job2.id) {
+              delete store.byFileId[String(job2.fileId)];
+            }
+            dirty = true;
+            continue;
+          }
+        }
+        result.push(store.byId[job2.id] ?? current);
+      }
+      if (dirty) {
+        await saveStore(store);
+      }
+      return result;
+    },
+    async clearJobsOnStartup() {
+      const store = await loadStore();
+      const jobCount = Object.keys(store.byId).length;
+      if (jobCount === 0) {
+        return;
+      }
+      await saveStore(emptyStore());
+      strapi.log.info(
+        `[video-optimizer] Cleared ${jobCount} persisted job(s) on startup (jobs are not resumed after restart)`
+      );
+    },
+    drainQueue,
+    cancelJobsForFile
+  };
+};
+const services = {
+  preference,
+  optimizer,
+  "job-queue": jobQueue
+};
+const index = {
+  register,
+  bootstrap,
+  config,
+  controllers,
+  routes,
+  services
+};
+export {
+  index as default
+};