@holo-js/media 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1520 @@
+// src/model/entity.ts
+import { Entity as Entity2 } from "@holo-js/db";
+
+// src/registry.ts
+import { Entity } from "@holo-js/db";
+
+// src/runtime/binary.ts
+import { basename, extname } from "path";
+var MIME_TYPES = Object.freeze({
+  avif: "image/avif",
+  gif: "image/gif",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  json: "application/json",
+  pdf: "application/pdf",
+  png: "image/png",
+  svg: "image/svg+xml",
+  txt: "text/plain",
+  webp: "image/webp"
+});
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "avif",
+  "gif",
+  "heic",
+  "heif",
+  "jpeg",
+  "jpg",
+  "png",
+  "svg",
+  "tif",
+  "tiff",
+  "webp"
+]);
+var SHARP_OUTPUT_FORMATS = /* @__PURE__ */ new Set([
+  "avif",
+  "jpeg",
+  "jpg",
+  "png",
+  "webp"
+]);
+function sanitizeFileName(value) {
+  const sanitized = value.trim().replace(/\\/g, "/").split("/").filter(Boolean).join("-");
+  return sanitized || "media.bin";
+}
+function inferMimeType(fileName, explicit) {
+  if (explicit?.trim()) {
+    return explicit.trim();
+  }
+  const extension = extname(fileName).replace(/^\./, "").toLowerCase();
+  return MIME_TYPES[extension];
+}
+function getExtension(fileName) {
+  const extension = extname(fileName).replace(/^\./, "").toLowerCase();
+  return extension || void 0;
+}
+function getDisplayName(fileName, explicit) {
+  if (explicit?.trim()) {
+    return explicit.trim();
+  }
+  return basename(fileName, extname(fileName));
+}
+async function toBinaryContent(value) {
+  if (value instanceof Blob) {
+    return new Uint8Array(await value.arrayBuffer());
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  return value;
+}
+async function toBuffer(value) {
+  const content = await toBinaryContent(value);
+  return Buffer.isBuffer(content) ? content : Buffer.from(content);
+}
+function getContentSize(value) {
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return value.byteLength;
+  }
+  return value.size;
+}
+function isImageSource(mimeType, extension) {
+  if (mimeType?.trim().toLowerCase().startsWith("image/")) {
+    return true;
+  }
+  return extension ? IMAGE_EXTENSIONS.has(extension.trim().toLowerCase()) : false;
+}
+function normalizeOutputFormat(extension, conversionFormat) {
+  if (conversionFormat) {
+    return conversionFormat;
+  }
+  const normalized = extension?.trim().toLowerCase();
+  if (normalized && SHARP_OUTPUT_FORMATS.has(normalized)) {
+    return normalized;
+  }
+  return "png";
+}
+function replaceFileExtension(fileName, extension) {
+  const baseName = basename(fileName, extname(fileName)) || "media";
+  return `${baseName}.${extension}`;
+}
+
+// src/runtime/image.ts
+var sharpFactoryPromise;
+async function loadSharp() {
+  sharpFactoryPromise ??= import("sharp").then((module) => {
+    const resolved = module;
+    return resolved.default ?? resolved;
+  }).catch((error) => {
+    sharpFactoryPromise = void 0;
+    throw error;
+  });
+  return sharpFactoryPromise;
+}
+function resolveFit(mode) {
+  switch (mode) {
+    case "contain":
+    case "cover":
+    case "fill":
+    case "inside":
+    case "outside":
+      return mode;
+    default:
+      return "cover";
+  }
+}
+function createDefaultMediaConversionExecutor() {
+  return {
+    async generate({ source, conversion: conversion2 }) {
+      if (!isImageSource(source.mimeType, source.extension)) {
+        return null;
+      }
+      const outputFormat = normalizeOutputFormat(source.extension, conversion2.format);
+      try {
+        const sharp = await loadSharp();
+        let pipeline = sharp(await toBuffer(source.contents), {
+          animated: true,
+          failOn: "warning"
+        }).rotate();
+        if (conversion2.width || conversion2.height) {
+          pipeline = pipeline.resize({
+            width: conversion2.width,
+            height: conversion2.height,
+            fit: resolveFit(conversion2.fit),
+            withoutEnlargement: true
+          });
+        }
+        switch (outputFormat) {
+          case "avif":
+            pipeline = pipeline.avif({
+              quality: conversion2.quality ?? 80,
+              effort: 4
+            });
+            break;
+          case "jpeg":
+          case "jpg":
+            pipeline = pipeline.jpeg({
+              quality: conversion2.quality ?? 82,
+              mozjpeg: true
+            });
+            break;
+          case "png":
+            pipeline = pipeline.png({
+              compressionLevel: 9,
+              quality: conversion2.quality
+            });
+            break;
+          case "webp":
+            pipeline = pipeline.webp({
+              quality: conversion2.quality ?? 82,
+              effort: 4
+            });
+            break;
+        }
+        const contents = await pipeline.toBuffer();
+        const fileName = replaceFileExtension(source.fileName, outputFormat);
+        return {
+          contents,
+          fileName,
+          mimeType: inferMimeType(fileName)
+        };
+      } catch (error) {
+        throw new Error(
+          `[Holo Media] Failed to generate conversion "${conversion2.name}" for "${source.fileName}": ${error.message}`
+        );
+      }
+    }
+  };
+}
+var defaultMediaConversionExecutor = createDefaultMediaConversionExecutor();
+
+// src/registry.ts
+var mediaDefinitionRegistry = /* @__PURE__ */ new WeakMap();
+var mediaDefinitionMorphClassRegistry = /* @__PURE__ */ new Map();
+function sanitizePathSegment(value) {
+  return value.trim().replace(/\\/g, "/").split("/").filter(Boolean).join("-");
+}
+function resolveConversionExtension(fileName, conversionFormat) {
+  if (conversionFormat) {
+    return conversionFormat === "jpg" ? "jpg" : conversionFormat;
+  }
+  const extension = fileName.split(".").pop()?.trim().toLowerCase();
+  return extension || "bin";
+}
+var defaultMediaPathGenerator = Object.freeze({
+  originalPath({
+    uuid,
+    fileName
+  }) {
+    return `media/${sanitizePathSegment(uuid)}/original/${sanitizePathSegment(fileName)}`;
+  },
+  conversionPath({
+    uuid,
+    conversion: conversion2,
+    generatedFileName,
+    fileName
+  }) {
+    const extension = resolveConversionExtension(generatedFileName ?? fileName, conversion2.format);
+    const safeName = sanitizePathSegment(conversion2.name);
+    return `media/${sanitizePathSegment(uuid)}/conversions/${safeName}.${extension}`;
+  }
+});
+var mediaPathGenerator = defaultMediaPathGenerator;
+var mediaConversionExecutor;
+function resolveDefinition(target) {
+  if (target instanceof Entity) {
+    return target.getRepository().definition;
+  }
+  return target.definition;
+}
+function registerMediaDefinition(target, definition) {
+  const resolvedTarget = resolveDefinition(target);
+  mediaDefinitionRegistry.set(resolvedTarget, definition);
+  mediaDefinitionMorphClassRegistry.set(resolvedTarget.morphClass ?? resolvedTarget.name, definition);
+  return definition;
+}
+function getMediaDefinition(target) {
+  return mediaDefinitionRegistry.get(resolveDefinition(target));
+}
+function requireMediaDefinition(target) {
+  const definition = getMediaDefinition(target);
+  if (!definition) {
+    const model = resolveDefinition(target);
+    throw new Error(
+      `[Holo Media] Model "${model.name}" is not configured for media. Wrap it with defineMediaModel().`
+    );
+  }
+  return definition;
+}
+function getMediaDefinitionForMorphClass(morphClass) {
+  return mediaDefinitionMorphClassRegistry.get(morphClass);
+}
+function requireMediaDefinitionForMorphClass(morphClass) {
+  const definition = getMediaDefinitionForMorphClass(morphClass);
+  if (!definition) {
+    throw new Error(
+      `[Holo Media] Model "${morphClass}" is not configured for media. Wrap it with defineMediaModel().`
+    );
+  }
+  return definition;
+}
+function resolveMediaCollection(target, collectionName = "default") {
+  const definition = getMediaDefinition(target);
+  if (!definition) {
+    return Object.freeze({
+      kind: "collection",
+      name: collectionName,
+      singleFile: false,
+      acceptedMimeTypes: Object.freeze([]),
+      acceptedExtensions: Object.freeze([])
+    });
+  }
+  return definition.collectionsByName[collectionName] ?? Object.freeze({
+    kind: "collection",
+    name: collectionName,
+    singleFile: false,
+    acceptedMimeTypes: Object.freeze([]),
+    acceptedExtensions: Object.freeze([])
+  });
+}
+function resolveMediaConversion(target, conversionName) {
+  return getMediaDefinition(target)?.conversionsByName[conversionName];
+}
+function setMediaPathGenerator(generator) {
+  mediaPathGenerator = generator;
+}
+function resetMediaPathGenerator() {
+  mediaPathGenerator = defaultMediaPathGenerator;
+}
+function getMediaPathGenerator() {
+  return mediaPathGenerator;
+}
+function setMediaConversionExecutor(executor) {
+  mediaConversionExecutor = executor;
+}
+function getMediaConversionExecutor() {
+  return mediaConversionExecutor ?? defaultMediaConversionExecutor;
+}
+function resetMediaRuntime() {
+  mediaPathGenerator = defaultMediaPathGenerator;
+  mediaConversionExecutor = void 0;
+}
+
+// src/model/Media.ts
+import { column, defineGeneratedTable, defineModel, morphTo } from "@holo-js/db";
+var mediaTable = defineGeneratedTable("media", {
+  id: column.id(),
+  uuid: column.uuid().unique(),
+  model_type: column.string(),
+  model_id: column.string(),
+  collection_name: column.string().default("default"),
+  name: column.string(),
+  file_name: column.string(),
+  disk: column.string(),
+  conversions_disk: column.string().nullable(),
+  mime_type: column.string().nullable(),
+  extension: column.string().nullable(),
+  size: column.bigInteger(),
+  path: column.string(),
+  generated_conversions: column.json("generated_conversions").default({}),
+  order_column: column.integer().default(1),
+  created_at: column.timestamp().defaultNow(),
+  updated_at: column.timestamp().defaultNow()
+}, {
+  indexes: [
+    { columns: ["model_type", "model_id"], unique: false },
+    { columns: ["model_type", "model_id", "collection_name"], unique: false }
+  ]
+});
+var Media = defineModel(mediaTable, {
+  fillable: [
+    "uuid",
+    "model_type",
+    "model_id",
+    "collection_name",
+    "name",
+    "file_name",
+    "disk",
+    "conversions_disk",
+    "mime_type",
+    "extension",
+    "size",
+    "path",
+    "generated_conversions",
+    "order_column"
+  ],
+  casts: {
+    generated_conversions: "json"
+  },
+  relations: {
+    model: morphTo("model")
+  }
+});
+
+// src/model/adder.ts
+import { basename as basename2 } from "path";
+import { readFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { Storage as Storage3 } from "@holo-js/storage/runtime";
+
+// src/queue.ts
+import {
+  dispatch,
+  defineJob,
+  getRegisteredQueueJob,
+  registerQueueJob
+} from "@holo-js/queue";
+import { connectionAsyncContext } from "@holo-js/db";
+
+// src/model/conversions.ts
+import { Storage } from "@holo-js/storage/runtime";
+function fallbackCollectionDefinition(collectionName) {
+  return Object.freeze({
+    kind: "collection",
+    name: collectionName,
+    singleFile: collectionName === "default",
+    acceptedMimeTypes: Object.freeze([]),
+    acceptedExtensions: Object.freeze([])
+  });
+}
+function normalizeRequestedConversions(requested) {
+  if (typeof requested === "string") {
+    return Object.freeze([requested]);
+  }
+  if (!requested || requested.length === 0) {
+    return void 0;
+  }
+  return Object.freeze([...new Set(requested.filter(Boolean))]);
+}
+function resolveCollectionDefinition(definition, collectionName) {
+  return definition.collectionsByName[collectionName] ?? fallbackCollectionDefinition(collectionName);
+}
+function resolveMatchingConversions(definition, collectionName, requested, options = {}) {
+  if (requested?.length) {
+    const unknown = requested.filter((name) => {
+      return !definition.conversionsByName[name];
+    });
+    if (unknown.length > 0) {
+      throw new Error(`[Holo Media] Unknown media conversion "${unknown[0]}".`);
+    }
+  }
+  const matching = definition.conversions.filter((conversion2) => {
+    const appliesToCollection = conversion2.collections.length === 0 || conversion2.collections.includes(collectionName);
+    if (!appliesToCollection) {
+      return false;
+    }
+    if (!requested?.length) {
+      return true;
+    }
+    return requested.includes(conversion2.name);
+  });
+  if (requested?.length) {
+    const missing = requested.filter((name) => {
+      return !matching.some((conversion2) => conversion2.name === name);
+    });
+    if (missing.length > 0) {
+      throw new Error(
+        `[Holo Media] Conversion "${missing[0]}" is not registered for collection "${collectionName}".`
+      );
+    }
+  }
+  if (options.includeQueued) {
+    return matching;
+  }
+  return matching.filter((conversion2) => !conversion2.queued);
+}
+function resolveQueuedConversionNames(options) {
+  const requested = normalizeRequestedConversions(options.requestedConversions);
+  return Object.freeze(
+    resolveMatchingConversions(
+      options.definition,
+      options.collectionName,
+      requested,
+      { includeQueued: true }
+    ).filter((conversion2) => conversion2.queued).map((conversion2) => conversion2.name)
+  );
+}
+async function generateStoredConversions(options) {
+  const requested = normalizeRequestedConversions(options.requestedConversions);
+  const matchingConversions = resolveMatchingConversions(
+    options.definition,
+    options.collection.name,
+    requested,
+    { includeQueued: options.includeQueued === true }
+  );
+  if (matchingConversions.length === 0) {
+    return Object.freeze({});
+  }
+  const generatedConversions = /* @__PURE__ */ Object.create(null);
+  const executor = getMediaConversionExecutor();
+  try {
+    for (const conversion2 of matchingConversions) {
+      const generated = await executor.generate({
+        source: options.source,
+        collection: options.collection,
+        conversion: conversion2
+      });
+      if (!generated) {
+        continue;
+      }
+      const generatedFileName = sanitizeFileName(generated.fileName ?? options.source.fileName);
+      const conversionPath = getMediaPathGenerator().conversionPath({
+        uuid: options.source.uuid,
+        fileName: options.source.fileName,
+        extension: options.source.extension,
+        collection: options.collection,
+        conversion: conversion2,
+        generatedFileName
+      });
+      const targetDisk = generated.disk ?? options.conversionsDisk;
+      const conversionMimeType = inferMimeType(generatedFileName, generated.mimeType);
+      const conversionContents = await toBinaryContent(generated.contents);
+      await Storage.disk(targetDisk).put(conversionPath, conversionContents);
+      generatedConversions[conversion2.name] = Object.freeze({
+        path: conversionPath,
+        disk: targetDisk,
+        fileName: generatedFileName,
+        mimeType: conversionMimeType,
+        size: getContentSize(conversionContents)
+      });
+    }
+  } catch (error) {
+    await deleteStoredConversions(
+      generatedConversions,
+      options.conversionsDisk
+    );
+    throw error;
+  }
+  return Object.freeze(generatedConversions);
+}
+async function deleteStoredConversions(conversions, _fallbackDisk) {
+  for (const conversion2 of Object.values(conversions)) {
+    await Storage.disk(conversion2.disk).delete(conversion2.path);
+  }
+}
+async function deleteObsoleteConversions(current, next, fallbackDisk, requested) {
+  for (const [name, conversion2] of Object.entries(current)) {
+    if (requested?.length && !requested.includes(name)) {
+      continue;
+    }
+    if (!conversion2?.path) {
+      continue;
+    }
+    const nextConversion = next[name];
+    if (nextConversion?.path === conversion2.path && nextConversion.disk === (conversion2.disk ?? fallbackDisk)) {
+      continue;
+    }
+    await Storage.disk(conversion2.disk ?? fallbackDisk).delete(conversion2.path);
+  }
+}
+async function regenerateMediaEntityConversions(options) {
+  const media = options.media;
+  const modelType = String(media.get("model_type"));
+  const definition = options.owner ? requireMediaDefinition(options.owner) : requireMediaDefinitionForMorphClass(modelType);
+  const collectionName = String(media.get("collection_name"));
+  const collection2 = resolveCollectionDefinition(definition, collectionName);
+  const requested = normalizeRequestedConversions(options.conversions);
+  const current = media.get("generated_conversions") ?? {};
+  const conversionsDisk = String(media.get("conversions_disk") ?? media.get("disk"));
+  resolveMatchingConversions(definition, collectionName, requested, {
+    includeQueued: options.includeQueued === true
+  });
+  const sourceContents = await Storage.disk(String(media.get("disk"))).getBytes(String(media.get("path")));
+  if (!sourceContents) {
+    throw new Error(
+      `[Holo Media] Cannot regenerate conversions for media "${media.get("uuid")}" because the original file is missing.`
+    );
+  }
+  const nextBase = requested?.length ? Object.fromEntries(
+    Object.entries(current).filter(([name]) => !requested.includes(name))
+  ) : {};
+  const regenerated = await generateStoredConversions({
+    definition,
+    collection: collection2,
+    conversionsDisk,
+    requestedConversions: requested,
+    includeQueued: options.includeQueued === true,
+    source: {
+      uuid: String(media.get("uuid")),
+      fileName: String(media.get("file_name")),
+      extension: media.get("extension") ?? void 0,
+      mimeType: media.get("mime_type") ?? void 0,
+      size: sourceContents.byteLength,
+      contents: sourceContents
+    }
+  });
+  const generatedConversions = Object.freeze({
+    ...nextBase,
+    ...regenerated
+  });
+  media.forceFill({
+    generated_conversions: generatedConversions
+  });
+  await media.save();
+  await deleteObsoleteConversions(current, generatedConversions, conversionsDisk, requested);
+  options.owner?.forgetRelation("media");
+  return generatedConversions;
+}
+
+// src/queue.ts
+var MEDIA_GENERATE_CONVERSIONS_JOB = "media.generate-conversions";
+function normalizeConversionNames(conversionNames) {
+  if (!conversionNames || conversionNames.length === 0) {
+    return void 0;
+  }
+  const normalized = [...new Set(
+    conversionNames.map((name) => name.trim()).filter(Boolean)
+  )];
+  return normalized.length > 0 ? Object.freeze(normalized) : void 0;
+}
+function normalizeMediaIdentifier(mediaId) {
+  if (typeof mediaId === "number") {
+    if (!Number.isFinite(mediaId)) {
+      throw new Error("[Holo Media] Queued media conversion jobs require a finite media identifier.");
+    }
+    return mediaId;
+  }
+  const normalized = mediaId.trim();
+  if (!normalized) {
+    throw new Error("[Holo Media] Queued media conversion jobs require a non-empty media identifier.");
+  }
+  return normalized;
+}
+function normalizePayload(payload) {
+  return Object.freeze({
+    mediaId: normalizeMediaIdentifier(payload.mediaId),
+    conversionNames: normalizeConversionNames(payload.conversionNames) ?? Object.freeze([])
+  });
+}
+async function runMediaGenerateConversionsJob(payload) {
+  const normalized = normalizePayload(payload);
+  const media = await Media.find(normalized.mediaId);
+  if (!media) {
+    return Object.freeze({
+      status: "missing-media",
+      conversionNames: Object.freeze([])
+    });
+  }
+  await regenerateMediaEntityConversions({
+    media,
+    conversions: normalized.conversionNames,
+    includeQueued: true
+  });
+  return Object.freeze({
+    status: "processed",
+    conversionNames: normalized.conversionNames
+  });
+}
+function ensureMediaQueueJobRegistered() {
+  if (getRegisteredQueueJob(MEDIA_GENERATE_CONVERSIONS_JOB)) {
+    return;
+  }
+  registerQueueJob(defineJob({
+    queue: "media",
+    async handle(payload) {
+      return runMediaGenerateConversionsJob(payload);
+    }
+  }), {
+    name: MEDIA_GENERATE_CONVERSIONS_JOB
+  });
+}
+function getActiveTransaction() {
+  const active = connectionAsyncContext.getActive()?.connection;
+  if (!active || active.getScope().kind === "root") {
+    return void 0;
+  }
+  return active;
+}
+async function executeQueuedMediaDispatch(payload, onSynchronousDispatch) {
+  const dispatched = await dispatch(MEDIA_GENERATE_CONVERSIONS_JOB, payload);
+  if (dispatched.synchronous) {
+    await onSynchronousDispatch?.();
+  }
+}
+async function dispatchQueuedMediaConversions(payload) {
+  const normalized = normalizePayload(payload);
+  if (normalized.conversionNames.length === 0) {
+    return;
+  }
+  ensureMediaQueueJobRegistered();
+  const activeTransaction = getActiveTransaction();
+  if (activeTransaction) {
+    activeTransaction.afterCommit(() => executeQueuedMediaDispatch(normalized));
+    return;
+  }
+  await executeQueuedMediaDispatch(normalized);
+}
+async function dispatchQueuedMediaConversionsForModel(payload, onSynchronousDispatch) {
+  const normalized = normalizePayload(payload);
+  if (normalized.conversionNames.length === 0) {
+    return;
+  }
+  ensureMediaQueueJobRegistered();
+  const activeTransaction = getActiveTransaction();
+  if (activeTransaction) {
+    activeTransaction.afterCommit(() => executeQueuedMediaDispatch(normalized, onSynchronousDispatch));
+    return;
+  }
+  await executeQueuedMediaDispatch(normalized, onSynchronousDispatch);
+}
+
+// src/model/item.ts
+import { Storage as Storage2 } from "@holo-js/storage/runtime";
+var MediaItem = class {
+  constructor(entity, owner) {
+    this.entity = entity;
+    this.owner = owner;
+  }
+  get record() {
+    return this.entity.toAttributes();
+  }
+  get collectionName() {
+    return this.entity.get("collection_name");
+  }
+  get fileName() {
+    return this.entity.get("file_name");
+  }
+  get mimeType() {
+    return this.entity.get("mime_type");
+  }
+  get size() {
+    return this.entity.get("size");
+  }
+  getEntity() {
+    return this.entity;
+  }
+  getAvailableConversions() {
+    const conversions = this.entity.get("generated_conversions");
+    return Object.freeze(
+      Object.keys(conversions ?? {})
+    );
+  }
+  getPath(conversion2) {
+    const variant = this.resolveVariant(conversion2);
+    if (!variant) {
+      return null;
+    }
+    try {
+      return Storage2.disk(variant.disk).path(variant.path);
+    } catch {
+      return null;
+    }
+  }
+  getUrl(conversion2) {
+    const variant = this.resolveVariant(conversion2);
+    if (!variant) {
+      return null;
+    }
+    try {
+      return Storage2.disk(variant.disk).url(variant.path);
+    } catch {
+      return null;
+    }
+  }
+  getTemporaryUrl(conversion2, options) {
+    const variant = this.resolveVariant(conversion2);
+    if (!variant) {
+      return null;
+    }
+    try {
+      return Storage2.disk(variant.disk).temporaryUrl(variant.path, options);
+    } catch {
+      return null;
+    }
+  }
+  async delete() {
+    const deletedSnapshots = [];
+    try {
+      for (const variant of this.resolveStoredVariants()) {
+        const disk = Storage2.disk(variant.disk);
+        const contents = await disk.getBytes(variant.path);
+        await disk.delete(variant.path);
+        if (contents) {
+          deletedSnapshots.push({
+            ...variant,
+            contents
+          });
+        }
+      }
+      await this.entity.delete();
+      this.owner?.forgetRelation("media");
+    } catch (error) {
+      for (const snapshot of deletedSnapshots.reverse()) {
+        await Storage2.disk(snapshot.disk).put(snapshot.path, snapshot.contents).catch(() => void 0);
+      }
+      throw error;
+    }
+  }
+  async regenerate(conversions) {
+    await regenerateMediaEntityConversions({
+      media: this.entity,
+      owner: this.owner,
+      conversions
+    });
+    const definition = this.owner ? requireMediaDefinition(this.owner) : requireMediaDefinitionForMorphClass(String(this.entity.get("model_type")));
+    const queuedConversions = resolveQueuedConversionNames({
+      definition,
+      collectionName: String(this.entity.get("collection_name")),
+      requestedConversions: conversions
+    });
+    await dispatchQueuedMediaConversionsForModel({
+      mediaId: this.entity.get("id"),
+      conversionNames: queuedConversions
+    }, async () => {
+      await this.entity.refresh();
+    });
+    return this;
+  }
+  toJSON() {
+    return this.entity.toJSON();
+  }
+  resolveVariant(conversion2) {
+    if (!conversion2) {
+      return {
+        path: this.entity.get("path"),
+        disk: this.entity.get("disk")
+      };
+    }
+    const conversions = this.entity.get("generated_conversions");
+    const variant = conversions?.[conversion2];
+    if (!variant?.path) {
+      return null;
+    }
+    return {
+      path: variant.path,
+      disk: variant.disk ?? this.entity.get("conversions_disk") ?? this.entity.get("disk")
+    };
+  }
+  resolveStoredVariants() {
+    const variants = [{
+      path: this.entity.get("path"),
+      disk: this.entity.get("disk")
+    }];
+    const fallbackDisk = this.entity.get("conversions_disk") ?? this.entity.get("disk");
+    const conversions = this.entity.get("generated_conversions") ?? {};
+    for (const value of Object.values(conversions)) {
+      if (!value?.path) {
+        continue;
+      }
+      variants.push({
+        path: value.path,
+        disk: value.disk ?? fallbackDisk
+      });
+    }
+    return variants;
+  }
+};
+
+// src/model/adder.ts
+function resolveImplicitDiskName() {
+  const defaultDisk = Storage3.disk();
+  if (defaultDisk.visibility === "public") {
+    return defaultDisk.name;
+  }
+  try {
+    const publicDisk = Storage3.disk("public");
+    if (publicDisk.visibility === "public") {
+      return publicDisk.name;
+    }
+  } catch {
+  }
+  return defaultDisk.name;
+}
+function parseRemoteFileName(url) {
+  try {
+    const parsedUrl = new URL(url);
+    return basename2(parsedUrl.pathname) || "media.bin";
+  } catch {
+    return "media.bin";
+  }
+}
+function createMaxSizeError(fileName, collectionName) {
+  return new Error(
+    `[Holo Media] File "${fileName}" exceeds the max size for collection "${collectionName}".`
+  );
+}
+async function readRemoteMediaContents(response, fileName, maxSize, collectionName) {
+  if (typeof maxSize !== "number" || !response.body) {
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let totalSize = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (!value) {
+        continue;
+      }
+      totalSize += value.byteLength;
+      if (totalSize > maxSize) {
+        await reader.cancel().catch(() => void 0);
+        throw createMaxSizeError(fileName, collectionName);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const contents = new Uint8Array(totalSize);
+  let offset = 0;
+  for (const chunk of chunks) {
+    contents.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return contents;
+}
+async function resolveMediaSource(input, overrideFileName, overrideName, options) {
+  if (typeof input === "string" && /^https?:\/\//i.test(input)) {
+    return resolveRemoteMediaSource(
+      { url: input },
+      overrideFileName,
+      overrideName,
+      options?.maxSize,
+      options?.collectionName
+    );
+  }
+  if (typeof input !== "string" && isUrlInput(input)) {
+    return resolveRemoteMediaSource(
+      input,
+      overrideFileName,
+      overrideName,
+      options?.maxSize,
+      options?.collectionName
+    );
+  }
+  if (typeof input === "string" || isPathInput(input)) {
+    const path = typeof input === "string" ? input : input.path;
+    const contents2 = await readFile(path);
+    const fileName2 = sanitizeFileName(overrideFileName ?? basename2(path));
+    return {
+      contents: contents2,
+      fileName: fileName2,
+      mimeType: inferMimeType(fileName2),
+      extension: getExtension(fileName2),
+      size: contents2.byteLength,
+      name: getDisplayName(fileName2, overrideName)
+    };
+  }
+  if ("contents" in input) {
+    const contents2 = await toBinaryContent(input.contents);
+    const fileName2 = sanitizeFileName(overrideFileName ?? input.fileName ?? "media.bin");
+    return {
+      contents: contents2,
+      fileName: fileName2,
+      mimeType: inferMimeType(fileName2, input.mimeType),
+      extension: getExtension(fileName2),
+      size: getContentSize(contents2),
+      name: getDisplayName(fileName2, overrideName ?? input.name)
+    };
+  }
+  const contents = await toBinaryContent(input);
+  const fileName = sanitizeFileName(overrideFileName ?? "media.bin");
+  return {
+    contents,
+    fileName,
+    mimeType: inferMimeType(fileName),
+    extension: getExtension(fileName),
+    size: getContentSize(contents),
+    name: getDisplayName(fileName, overrideName)
+  };
+}
+function isPathInput(input) {
+  return typeof input === "object" && input !== null && "path" in input;
+}
+function isUrlInput(input) {
+  return typeof input === "object" && input !== null && "url" in input;
+}
+async function resolveRemoteMediaSource(input, overrideFileName, overrideName, maxSize, collectionName) {
+  const response = await fetch(input.url);
+  if (!response.ok) {
+    throw new Error(
+      `[Holo Media] Failed to download media from "${input.url}" (${response.status} ${response.statusText}).`
+    );
+  }
+  const fileName = sanitizeFileName(
+    overrideFileName ?? input.fileName ?? parseRemoteFileName(input.url)
+  );
+  const responseMimeType = response.headers.get("content-type")?.split(";")[0];
+  const contentLengthHeader = response.headers.get("content-length");
+  const contentLength = contentLengthHeader?.trim() ? Number(contentLengthHeader) : Number.NaN;
+  if (typeof maxSize === "number" && Number.isFinite(contentLength) && contentLength > maxSize) {
+    throw createMaxSizeError(fileName, collectionName);
+  }
+  const contents = await readRemoteMediaContents(
+    response,
+    fileName,
+    maxSize,
+    collectionName
+  );
+  return {
+    contents,
+    fileName,
+    mimeType: inferMimeType(fileName, input.mimeType ?? responseMimeType ?? void 0),
+    extension: getExtension(fileName),
+    size: contents.byteLength,
+    name: getDisplayName(fileName, overrideName ?? input.name)
+  };
+}
+function validateSource(collection2, source) {
+  if (typeof collection2.maxSize === "number" && source.size > collection2.maxSize) {
+    throw new Error(
+      `[Holo Media] File "${source.fileName}" exceeds the max size for collection "${collection2.name}".`
+    );
+  }
+  if (collection2.acceptedMimeTypes.length > 0) {
+    const mimeType = source.mimeType?.trim().toLowerCase();
+    if (!mimeType || !collection2.acceptedMimeTypes.includes(mimeType)) {
+      throw new Error(
+        `[Holo Media] File "${source.fileName}" is not an accepted MIME type for collection "${collection2.name}".`
+      );
+    }
+  }
+  if (collection2.acceptedExtensions.length > 0) {
+    if (!source.extension || !collection2.acceptedExtensions.includes(source.extension)) {
+      throw new Error(
+        `[Holo Media] File "${source.fileName}" is not an accepted extension for collection "${collection2.name}".`
+      );
+    }
+  }
+}
+async function resolveNextOrderColumn(modelType, modelId, collectionName) {
+  const max = await Media.query().where("model_type", modelType).where("model_id", modelId).where("collection_name", collectionName).max("order_column");
+  return (max ?? 0) + 1;
+}
+async function deleteMediaItemsWithRollback(items) {
+  const deletedSnapshots = [];
+  try {
+    for (const item of items) {
+      const snapshot = await snapshotDeletedMediaItem(item);
+      await item.delete();
+      deletedSnapshots.push(snapshot);
+    }
+  } catch (error) {
+    for (const snapshot of deletedSnapshots.reverse()) {
+      await restoreDeletedMediaSnapshot(snapshot).catch(() => void 0);
+    }
+    throw error;
+  }
+}
+async function deleteOverflowItems(items, limit) {
+  if (items.length <= limit) {
+    return;
+  }
+  await deleteMediaItemsWithRollback(items.slice(0, items.length - limit));
+}
+async function cleanupGeneratedConversions(conversions, _fallbackDisk) {
+  for (const conversion2 of Object.values(conversions)) {
+    await Storage3.disk(conversion2.disk).delete(conversion2.path).catch(() => void 0);
+  }
+}
+async function snapshotDeletedMediaItem(item) {
+  const record = item.record;
+  const fileTargets = [{
+    disk: record.disk,
+    path: record.path
+  }];
+  const fallbackDisk = record.conversions_disk ?? record.disk;
+  for (const conversion2 of Object.values(record.generated_conversions ?? {})) {
+    if (!conversion2?.path) {
+      continue;
+    }
+    fileTargets.push({
+      disk: conversion2.disk ?? fallbackDisk,
+      path: conversion2.path
+    });
+  }
+  const files = (await Promise.all(fileTargets.map(async (file) => {
+    const contents = await Storage3.disk(file.disk).getBytes(file.path);
+    return contents ? {
+      ...file,
+      contents
+    } : null;
+  }))).filter((file) => Boolean(file));
+  return {
+    record: {
+      uuid: record.uuid,
+      model_type: record.model_type,
+      model_id: record.model_id,
+      collection_name: record.collection_name,
+      name: record.name,
+      file_name: record.file_name,
+      disk: record.disk,
+      conversions_disk: record.conversions_disk,
+      mime_type: record.mime_type,
+      extension: record.extension,
+      size: record.size,
+      path: record.path,
+      generated_conversions: record.generated_conversions,
+      order_column: record.order_column
+    },
+    files
+  };
+}
+async function restoreDeletedMediaSnapshot(snapshot) {
+  for (const file of snapshot.files) {
+    await Storage3.disk(file.disk).put(file.path, file.contents);
+  }
+  await Media.create(snapshot.record);
+}
+var MediaAdder = class _MediaAdder {
+  constructor(entity, source, state = {}) {
+    this.entity = entity;
+    this.source = source;
+    this.state = state;
+  }
+  usingName(name) {
+    return new _MediaAdder(this.entity, this.source, {
+      ...this.state,
+      name
+    });
+  }
+  usingFileName(fileName) {
+    return new _MediaAdder(this.entity, this.source, {
+      ...this.state,
+      fileName
+    });
+  }
+  onDisk(disk) {
+    return new _MediaAdder(this.entity, this.source, {
+      ...this.state,
+      disk
+    });
+  }
+  async toMediaCollection(collectionName = "default") {
+    const mediaDefinition = requireMediaDefinition(this.entity);
+    const ownerDefinition = this.entity.getRepository().definition;
+    const ownerId = this.entity.get(ownerDefinition.primaryKey);
+    if (ownerId === null || typeof ownerId === "undefined") {
+      throw new Error(
+        `[Holo Media] Cannot attach media to "${ownerDefinition.name}" before it has a persisted primary key.`
+      );
+    }
+    const collection2 = resolveMediaCollection(this.entity, collectionName);
+    const source = await resolveMediaSource(
+      this.source,
+      this.state.fileName,
+      this.state.name,
+      {
+        maxSize: collection2.maxSize,
+        collectionName: collection2.name
+      }
+    );
+    validateSource(collection2, source);
+    const existing = collection2.singleFile ? await this.entity.getMedia(collectionName) : [];
+    const uuid = randomUUID();
+    const diskName = this.state.disk ?? collection2.disk ?? resolveImplicitDiskName();
+    const conversionsDisk = collection2.conversionsDisk ?? diskName;
+    const originalPath = getMediaPathGenerator().originalPath({
+      uuid,
+      fileName: source.fileName,
+      extension: source.extension,
+      collection: collection2
+    });
+    let originalStored = false;
+    let createdMedia;
+    let generatedConversions = Object.freeze({});
+    try {
+      await Storage3.disk(diskName).put(originalPath, source.contents);
+      originalStored = true;
+      generatedConversions = await generateStoredConversions({
+        definition: mediaDefinition,
+        collection: collection2,
+        conversionsDisk,
+        source: {
+          uuid,
+          fileName: source.fileName,
+          extension: source.extension,
+          mimeType: source.mimeType,
+          size: source.size,
+          contents: source.contents
+        }
+      });
+      const media = await Media.create({
+        uuid,
+        model_type: ownerDefinition.morphClass,
+        model_id: String(ownerId),
+        collection_name: collectionName,
+        name: source.name,
+        file_name: source.fileName,
+        disk: diskName,
+        conversions_disk: conversionsDisk,
+        mime_type: source.mimeType ?? null,
+        extension: source.extension ?? null,
+        size: source.size,
+        path: originalPath,
+        generated_conversions: generatedConversions,
+        order_column: await resolveNextOrderColumn(
+          ownerDefinition.morphClass,
+          String(ownerId),
+          collectionName
+        )
+      });
+      createdMedia = media;
+      this.entity.forgetRelation("media");
+      await deleteMediaItemsWithRollback(existing);
+      if (typeof collection2.onlyKeepLatest === "number") {
+        const items = await this.entity.getMedia(collectionName);
+        await deleteOverflowItems(items, collection2.onlyKeepLatest);
+      }
+      const queuedConversions = resolveQueuedConversionNames({
+        definition: mediaDefinition,
+        collectionName: collection2.name
+      });
+      await dispatchQueuedMediaConversionsForModel({
+        mediaId: media.get("id"),
+        conversionNames: queuedConversions
+      }, async () => {
+        await media.refresh();
+      });
+      return new MediaItem(media, this.entity);
+    } catch (error) {
+      await cleanupGeneratedConversions(generatedConversions, conversionsDisk).catch(() => void 0);
+      if (originalStored) {
+        await Storage3.disk(diskName).delete(originalPath).catch(() => void 0);
+      }
+      if (createdMedia) {
+        await createdMedia.refresh().catch(() => void 0);
+        await createdMedia.delete().catch(() => void 0);
+      }
+      this.entity.forgetRelation("media");
+      throw error;
+    }
+  }
+};
+
+// src/model/entity.ts
+function getOwnerKey(entity) {
+  const ownerDefinition = entity.getRepository().definition;
+  const ownerId = entity.get(ownerDefinition.primaryKey);
+  if (ownerId === null || typeof ownerId === "undefined") {
+    return null;
+  }
+  return String(ownerId);
+}
+function createQuery(entity, collectionName) {
+  const mediaDefinition = getMediaDefinition(entity);
+  if (!mediaDefinition) {
+    return null;
+  }
+  const ownerDefinition = entity.getRepository().definition;
+  const ownerId = getOwnerKey(entity);
+  if (!ownerId) {
+    return null;
+  }
+  let query = Media.query().where("model_type", ownerDefinition.morphClass).where("model_id", ownerId);
+  if (collectionName) {
+    query = query.where("collection_name", collectionName);
+  }
+  return query.orderBy("order_column").orderBy("id");
+}
+function installEntityMediaMethods() {
+  const prototype = Entity2.prototype;
+  if (prototype.__holoMediaInstalled__) {
+    return;
+  }
+  prototype.__holoMediaInstalled__ = true;
+  prototype.addMedia = function addMedia(source) {
+    return new MediaAdder(this, source);
+  };
+  prototype.addMediaFromUrl = function addMediaFromUrl(url) {
+    return new MediaAdder(this, { url });
+  };
+  prototype.getMedia = async function getMedia(collectionName) {
+    const query = createQuery(this, collectionName);
+    if (!query) {
+      return [];
+    }
+    const rows = await query.get();
+    return rows.map((row) => {
+      return new MediaItem(row, this);
+    });
+  };
+  prototype.getMediaUrls = async function getMediaUrls(collectionName, conversionName) {
+    const items = await this.getMedia(collectionName);
+    return items.map((item) => item.getUrl(conversionName)).filter((value) => typeof value === "string");
+  };
+  prototype.getMediaPaths = async function getMediaPaths(collectionName, conversionName) {
+    const items = await this.getMedia(collectionName);
+    return items.map((item) => item.getPath(conversionName)).filter((value) => typeof value === "string");
+  };
+  prototype.getFirstMedia = async function getFirstMedia(collectionName) {
+    const query = createQuery(this, collectionName);
+    if (!query) {
+      return null;
+    }
+    const row = await query.first();
+    return row ? new MediaItem(row, this) : null;
+  };
+  prototype.getFirstMediaUrl = async function getFirstMediaUrl(collectionName, conversionName) {
+    const item = await this.getFirstMedia(collectionName);
+    return item?.getUrl(conversionName) ?? null;
+  };
+  prototype.getFirstMediaPath = async function getFirstMediaPath(collectionName, conversionName) {
+    const item = await this.getFirstMedia(collectionName);
+    return item?.getPath(conversionName) ?? null;
+  };
+  prototype.getFirstTemporaryUrl = async function getFirstTemporaryUrl(collectionName, conversionName, options) {
+    const item = await this.getFirstMedia(collectionName);
+    return item?.getTemporaryUrl(conversionName, options) ?? null;
+  };
+  prototype.hasMedia = async function hasMedia(collectionName) {
+    const query = createQuery(this, collectionName);
+    if (!query) {
+      return false;
+    }
+    return query.exists();
+  };
+  prototype.clearMediaCollection = async function clearMediaCollection(collectionName) {
+    const items = await this.getMedia(collectionName);
+    for (const item of items) {
+      await item.delete();
+    }
+  };
+  prototype.regenerateMedia = async function regenerateMedia(collectionName, conversions) {
+    const items = await this.getMedia(collectionName);
+    for (const item of items) {
+      await item.regenerate(conversions);
+    }
+  };
+}
+
+// src/defineMediaModel.ts
+import { morphMany } from "@holo-js/db";
+
+// src/definitions/collections.ts
+function decorateCollection(definition) {
+  const clone = (overrides) => decorateCollection(Object.freeze({
+    ...definition,
+    ...overrides
+  }));
+  return Object.freeze({
+    kind: definition.kind,
+    name: definition.name,
+    definition,
+    disk(diskName) {
+      return clone({ diskName: diskName.trim() || void 0 });
+    },
+    conversionsDisk(diskName) {
+      return clone({ conversionsDiskName: diskName.trim() || void 0 });
+    },
+    singleFile() {
+      return clone({ singleFile: true, onlyKeepLatest: 1 });
+    },
+    onlyKeepLatest(limit) {
+      return clone({
+        onlyKeepLatest: Math.max(1, Math.floor(limit))
+      });
+    },
+    acceptsMimeTypes(mimeTypes) {
+      return clone({
+        acceptedMimeTypes: Object.freeze(
+          mimeTypes.map((mimeType) => mimeType.trim()).map((mimeType) => mimeType.toLowerCase()).filter(Boolean)
+        )
+      });
+    },
+    acceptsExtensions(extensions) {
+      return clone({
+        acceptedExtensions: Object.freeze(
+          extensions.map((extension) => extension.trim().replace(/^\./, "").toLowerCase()).filter(Boolean)
+        )
+      });
+    },
+    maxSize(bytes) {
+      return clone({
+        maxFileSize: Math.max(1, Math.floor(bytes))
+      });
+    }
+  });
+}
+function collection(name) {
+  return decorateCollection(Object.freeze({
+    kind: "collection",
+    name,
+    singleFile: false,
+    acceptedMimeTypes: Object.freeze([]),
+    acceptedExtensions: Object.freeze([])
+  }));
+}
+function normalizeCollectionDefinitions(definitions) {
+  return Object.freeze(definitions.map((definition) => {
+    return Object.freeze({
+      ...definition,
+      disk: definition.diskName?.trim() || void 0,
+      conversionsDisk: definition.conversionsDiskName?.trim() || void 0,
+      singleFile: Boolean(definition.singleFile),
+      onlyKeepLatest: typeof definition.onlyKeepLatest === "number" ? Math.max(1, Math.floor(definition.onlyKeepLatest)) : void 0,
+      acceptedMimeTypes: Object.freeze(
+        definition.acceptedMimeTypes.map((mimeType) => mimeType.trim()).map((mimeType) => mimeType.toLowerCase()).filter(Boolean)
+      ),
+      acceptedExtensions: Object.freeze(
+        definition.acceptedExtensions.map((extension) => extension.trim().replace(/^\./, "").toLowerCase()).filter(Boolean)
+      ),
+      maxSize: typeof definition.maxFileSize === "number" ? Math.max(1, Math.floor(definition.maxFileSize)) : void 0
+    });
+  }));
+}
+
+// src/definitions/conversions.ts
+function decorateConversion(definition) {
+  const clone = (overrides) => decorateConversion(Object.freeze({
+    ...definition,
+    ...overrides
+  }));
+  return Object.freeze({
+    kind: definition.kind,
+    name: definition.name,
+    definition,
+    performOnCollections(...collections) {
+      return clone({
+        collections: Object.freeze(
+          collections.filter(Boolean)
+        )
+      });
+    },
+    width(pixels) {
+      return clone({
+        width: Math.max(1, Math.floor(pixels))
+      });
+    },
+    height(pixels) {
+      return clone({
+        height: Math.max(1, Math.floor(pixels))
+      });
+    },
+    fit(mode) {
+      return clone({ fit: mode });
+    },
+    format(format) {
+      return clone({ format });
+    },
+    quality(value) {
+      return clone({
+        quality: Math.max(1, Math.min(100, Math.floor(value)))
+      });
+    },
+    queued() {
+      return clone({ queued: true });
+    },
+    nonQueued() {
+      return clone({ queued: false });
+    }
+  });
+}
+function conversion(name) {
+  return decorateConversion(Object.freeze({
+    kind: "conversion",
+    name,
+    collections: Object.freeze([]),
+    queued: false
+  }));
+}
+function normalizeConversionDefinitions(definitions) {
+  return Object.freeze(definitions.map((definition) => {
+    return Object.freeze({
+      ...definition,
+      collections: Object.freeze(
+        definition.collections.filter(Boolean)
+      ),
+      width: typeof definition.width === "number" ? Math.max(1, Math.floor(definition.width)) : void 0,
+      height: typeof definition.height === "number" ? Math.max(1, Math.floor(definition.height)) : void 0,
+      quality: typeof definition.quality === "number" ? Math.max(1, Math.min(100, Math.floor(definition.quality))) : void 0,
+      queued: Boolean(definition.queued)
+    });
+  }));
+}
+
+// src/definitions/config.ts
+function resolveMediaDefinition(input) {
+  if (typeof input === "function") {
+    return input({ collection, conversion });
+  }
+  return input;
+}
+function normalizeMediaDefinition(input) {
+  const collections = normalizeCollectionDefinitions(
+    (input.collections ?? []).map((item) => item.definition)
+  );
+  const conversions = normalizeConversionDefinitions(
+    (input.conversions ?? []).map((item) => item.definition)
+  );
+  const collectionsByName = /* @__PURE__ */ Object.create(null);
+  for (const definition of collections) {
+    if (collectionsByName[definition.name]) {
+      throw new Error(`[Holo Media] Duplicate media collection "${definition.name}".`);
+    }
+    collectionsByName[definition.name] = definition;
+  }
+  const conversionsByName = /* @__PURE__ */ Object.create(null);
+  for (const definition of conversions) {
+    if (conversionsByName[definition.name]) {
+      throw new Error(`[Holo Media] Duplicate media conversion "${definition.name}".`);
+    }
+    for (const collectionName of definition.collections) {
+      if (!collectionsByName[collectionName]) {
+        throw new Error(
+          `[Holo Media] Conversion "${definition.name}" references unknown collection "${collectionName}".`
+        );
+      }
+    }
+    conversionsByName[definition.name] = definition;
+  }
+  return Object.freeze({
+    collections,
+    conversions,
+    collectionsByName: Object.freeze(collectionsByName),
+    conversionsByName: Object.freeze(conversionsByName)
+  });
+}
+
+// src/defineMediaModel.ts
+function defineMediaModel(model, definition) {
+  installEntityMediaMethods();
+  const resolvedDefinition = normalizeMediaDefinition(
+    resolveMediaDefinition(definition)
+  );
+  registerMediaDefinition(model, resolvedDefinition);
+  model.resolveRelationUsing("media", () => morphMany(
+    () => Media,
+    "model"
+  ));
+  return model;
+}
+
+// src/index.ts
+installEntityMediaMethods();
+ensureMediaQueueJobRegistered();
+export {
+  MEDIA_GENERATE_CONVERSIONS_JOB,
+  Media,
+  MediaAdder,
+  MediaItem,
+  collection,
+  conversion,
+  createDefaultMediaConversionExecutor,
+  defaultMediaConversionExecutor,
+  defineMediaModel,
+  dispatchQueuedMediaConversions,
+  ensureMediaQueueJobRegistered,
+  getMediaConversionExecutor,
+  getMediaDefinition,
+  getMediaDefinitionForMorphClass,
+  getMediaPathGenerator,
+  normalizeCollectionDefinitions,
+  normalizeConversionDefinitions,
+  normalizeMediaDefinition,
+  registerMediaDefinition,
+  requireMediaDefinition,
+  requireMediaDefinitionForMorphClass,
+  resetMediaPathGenerator,
+  resetMediaRuntime,
+  resolveMediaCollection,
+  resolveMediaConversion,
+  resolveMediaDefinition,
+  runMediaGenerateConversionsJob,
+  setMediaConversionExecutor,
+  setMediaPathGenerator
+};