@zerotal/media 1.3.0

package/src/commands/MediaRegenerateCommand.ts

@@ -0,0 +1,89 @@
+import { Command } from "@zerotal/core";
+import type { FlagDef } from "@zerotal/core";
+import { MediaItem } from "../MediaItem.ts";
+import { MediaLibrary } from "../facades/MediaLibrary.ts";
+import { ownerClassFor } from "../conversions/queueBridge.ts";
+import { hasCollection } from "../collections/resolve.ts";
+
+/**
+ * Rebuild conversions for existing media — the command you run after widening a
+ * thumbnail or adding a conversion to a collection that already has files in it.
+ *
+ * @example
+ * ```bash
+ * bun zt media:regenerate                          # everything
+ * bun zt media:regenerate --model=Product          # one model
+ * bun zt media:regenerate --only=thumb,hero        # named conversions
+ * bun zt media:regenerate --id=42                  # one item
+ * ```
+ */
+export class MediaRegenerateCommand extends Command {
+  static override commandName = "media:regenerate";
+  static override description = "Regenerate conversions for existing media";
+  static override needsApp = true;
+  static override flags: FlagDef[] = [
+    { name: "model", type: "string", description: "Only media owned by this model type" },
+    { name: "id", type: "string", description: "Only this media id" },
+    { name: "only", type: "string", description: "Comma-separated conversion names" },
+  ];
+
+  async run(): Promise<void> {
+    const only = this.parseOnly();
+    const media = await this.select();
+
+    if (media.length === 0) {
+      this.warn("No media matched.");
+      return;
+    }
+
+    let regenerated = 0;
+    let skipped = 0;
+
+    for (const item of media) {
+      const ownerClass = ownerClassFor(item.modelType);
+
+      // A model_type that no longer resolves is not a failure worth stopping
+      // for: a renamed or deleted model leaves rows behind, and the run should
+      // still process everything else.
+      if (ownerClass === null || !hasCollection(ownerClass, item.collectionName)) {
+        skipped++;
+        continue;
+      }
+
+      const generated = await MediaLibrary.regenerate(item, ownerClass, only);
+      if (generated.length > 0) regenerated++;
+    }
+
+    this.info(`Regenerated conversions for ${regenerated} of ${media.length} item(s).`);
+    if (skipped > 0) {
+      this.warn(
+        `${skipped} skipped — their model type or collection is no longer declared. ` +
+          "Run `bun zt media:clean` to review them.",
+      );
+    }
+  }
+
+  private parseOnly(): string[] | undefined {
+    const raw = this.flags["only"];
+    if (typeof raw !== "string" || raw.trim() === "") return undefined;
+    return raw
+      .split(",")
+      .map((name) => name.trim())
+      .filter(Boolean);
+  }
+
+  private async select(): Promise<MediaItem[]> {
+    const id = this.flags["id"];
+    if (typeof id === "string" && id.trim() !== "") {
+      const one = await MediaItem.find(id.trim());
+      return one === null ? [] : [one];
+    }
+
+    const model = this.flags["model"];
+    if (typeof model === "string" && model.trim() !== "") {
+      return MediaItem.query().where("model_type", model.trim()).get();
+    }
+
+    return MediaItem.query().get();
+  }
+}

package/src/commands/index.ts

@@ -0,0 +1,2 @@
+export { MediaCleanCommand } from "./MediaCleanCommand.ts";
+export { MediaRegenerateCommand } from "./MediaRegenerateCommand.ts";

package/src/config.ts

@@ -0,0 +1,89 @@
+import { deepMerge } from "@zerotal/core";
+import type { SafeConversionFormat } from "./types.ts";
+
+export interface MediaConfigShape {
+  /**
+   * Disk originals go to when a collection does not name one.
+   * Empty string means "whatever `storage.default` resolves to".
+   */
+  disk: string;
+  /** Disk conversions go to. Empty string means "the same disk as the original". */
+  conversionsDisk: string;
+  /** Table backing the {@link MediaItem} model. */
+  table: string;
+  /**
+   * Provision the media table at boot instead of requiring a migration.
+   * Idempotent; skipped when the table already exists or there is no database.
+   */
+  autoCreateTable: boolean;
+  /** Image driver. `"bun"` needs no dependencies; `"sharp"` adds crop support. */
+  driver: "bun" | "sharp";
+  /**
+   * Run conversions through the queue when one is bound and the conversion asks
+   * for it. With no queue bound, conversions always run inline.
+   */
+  queueConversions: boolean;
+  /** Queue name conversion jobs are dispatched to. */
+  queue: string;
+  /** Default encoder quality (1–100) when a conversion does not set one. */
+  quality: number;
+  /** Default output format when a conversion does not set one. */
+  format: SafeConversionFormat;
+  /**
+   * Refuse to decode an image larger than this, in bytes.
+   *
+   * `Bun.Image` has no streaming API — the whole file is buffered to decode it,
+   * then again to encode. Without a ceiling one 400 MB upload takes the worker
+   * down. Originals above it are still stored; they just get no conversions.
+   */
+  maxConversionInputSize: number;
+  /** Widths generated for `responsive: true` collections. */
+  responsiveWidths: number[];
+  /** Generate the inline blur placeholder alongside responsive images. */
+  responsivePlaceholder: boolean;
+  /**
+   * Permit AVIF/HEIC conversion targets. Off by default: they depend on OS
+   * codecs that are frequently missing, and the failure lands in a background
+   * job rather than in the request that configured it.
+   */
+  allowHostFormats: boolean;
+}
+
+const defaults: MediaConfigShape = {
+  disk: "",
+  conversionsDisk: "",
+  table: "media",
+  autoCreateTable: true,
+  driver: "bun",
+  queueConversions: true,
+  queue: "default",
+  quality: 82,
+  format: "webp",
+  maxConversionInputSize: 32 * 1024 * 1024,
+  responsiveWidths: [320, 640, 960, 1280, 1920],
+  responsivePlaceholder: true,
+  allowHostFormats: false,
+};
+
+/**
+ * Create a typed media configuration object with defaults.
+ *
+ * @example
+ * import { MediaConfig } from '@zerotal/media';
+ * export default MediaConfig({ disk: 's3', driver: 'sharp' });
+ */
+export function MediaConfig(options: Partial<MediaConfigShape> = {}): MediaConfigShape {
+  return deepMerge(defaults, options);
+}
+
+/** The defaults, for tests and for resolving config in DB-less runtimes. */
+export function mediaDefaults(): MediaConfigShape {
+  return { ...defaults, responsiveWidths: [...defaults.responsiveWidths] };
+}
+
+// Register this package's config namespace for typed config() dot-paths.
+declare module "@zerotal/core" {
+  interface ConfigRegistry {
+    media: MediaConfigShape;
+  }
+}

package/src/conversions/BunImageDriver.ts

@@ -0,0 +1,183 @@
+import {
+  FORMAT_MIME,
+  type ImageDriver,
+  type ImageManipulation,
+  type ImageMetadata,
+  type ImageResult,
+} from "./ImageDriver.ts";
+import { UnsupportedFormatError, UnsupportedManipulationError } from "../errors.ts";
+import type { ConversionFormat } from "../types.ts";
+
+/**
+ * Image processing on `Bun.Image` — no native modules, no `sharp`, nothing to
+ * install. JPEG, PNG and WebP are statically linked into Bun itself.
+ *
+ * ## What it cannot do
+ *
+ * `Bun.Image.resize()` takes `fit: "fill" | "inside"` and the class exposes no
+ * crop, extract or composite primitive. A centre-cropped thumbnail — a square
+ * from a 3:2 photo — is therefore not expressible, and `fit: "cover"` throws
+ * {@link UnsupportedManipulationError} naming the fix rather than silently
+ * returning a stretched image. Apps that need crop install `sharp` and switch to
+ * `SharpImageDriver` via `media.driver`.
+ *
+ * ## Host-dependent formats
+ *
+ * `Bun.Image.backend` is `"system"` by default, so AVIF and HEIC encode through
+ * OS codecs that are absent on most Linux hosts. {@link canEncode} probes for
+ * real rather than assuming, and `MediaProvider` runs that probe once at boot.
+ */
+export class BunImageDriver implements ImageDriver {
+  readonly name = "BunImageDriver";
+  readonly supportsCrop = false;
+
+  /** Memoised results of {@link canEncode}, which costs a real encode. */
+  readonly #encodable = new Map<ConversionFormat, boolean>();
+
+  constructor(
+    /**
+     * Cap on input pixels, guarding against decompression bombs: a few-KB file
+     * declaring a 50000×50000 canvas would otherwise allocate gigabytes. Checked
+     * against the header before any pixel buffer is allocated.
+     */
+    private readonly maxPixels: number = 0x3fff * 0x3fff,
+  ) {}
+
+  async metadata(bytes: Uint8Array): Promise<ImageMetadata | null> {
+    try {
+      const meta = await new Bun.Image(bytes, { maxPixels: this.maxPixels }).metadata();
+      return { width: meta.width, height: meta.height, format: meta.format };
+    } catch {
+      // Not an image, or a format this host cannot decode. Callers treat null as
+      // "not convertible" and keep the original — never a hard failure.
+      return null;
+    }
+  }
+
+  async convert(bytes: Uint8Array, manipulation: ImageManipulation): Promise<ImageResult> {
+    const { width, height, fit = "inside", format, quality, rotate } = manipulation;
+
+    if (fit === "cover") {
+      throw new UnsupportedManipulationError(
+        this.name,
+        'centre-crop (fit: "cover") — Bun.Image supports only fit: "fill" | "inside" ' +
+          "and exposes no crop primitive",
+        'either use fit: "inside" (scale to fit, preserves aspect ratio) or ' +
+          'install sharp and set `driver: "sharp"` in config/media.ts.',
+      );
+    }
+
+    let pipeline = new Bun.Image(bytes, { maxPixels: this.maxPixels });
+
+    if (rotate !== undefined && rotate !== 0) pipeline = pipeline.rotate(rotate);
+
+    if (width !== undefined || height !== undefined) {
+      // Bun.Image needs a width; when only a height is given, pass the height
+      // through as the bound and let `inside` preserve the aspect ratio.
+      const targetWidth = width ?? height!;
+      pipeline = pipeline.resize(targetWidth, height, {
+        fit,
+        // Upscaling a 200px source to fill a 1920px slot produces a blurry file
+        // larger than the original. Never worth it by default.
+        withoutEnlargement: manipulation.withoutEnlargement ?? true,
+      });
+    }
+
+    pipeline = _applyFormat(pipeline, format, quality);
+
+    let out: Uint8Array;
+    try {
+      out = await pipeline.bytes();
+    } catch (error) {
+      if (_codeOf(error) === "ERR_IMAGE_FORMAT_UNSUPPORTED") {
+        throw new UnsupportedFormatError(format, await this.encodableFormats());
+      }
+      throw error;
+    }
+
+    return {
+      bytes: out,
+      // Populated once a terminal has been awaited; -1 before that.
+      width: pipeline.width,
+      height: pipeline.height,
+      format,
+      mimeType: FORMAT_MIME[format],
+    };
+  }
+
+  async placeholder(bytes: Uint8Array): Promise<string | null> {
+    try {
+      // ThumbHash-rendered: a ~32px blur carrying the right average colour and
+      // aspect ratio, around 400–700 bytes, ready for `<img src>`.
+      return await new Bun.Image(bytes, { maxPixels: this.maxPixels }).placeholder("dataurl");
+    } catch {
+      return null;
+    }
+  }
+
+  async canEncode(format: ConversionFormat): Promise<boolean> {
+    const cached = this.#encodable.get(format);
+    if (cached !== undefined) return cached;
+
+    let ok: boolean;
+    try {
+      await _applyFormat(new Bun.Image(_PROBE_PNG).resize(2, 2), format, 60).bytes();
+      ok = true;
+    } catch (error) {
+      if (_codeOf(error) === "ERR_IMAGE_FORMAT_UNSUPPORTED") ok = false;
+      else throw error;
+    }
+
+    this.#encodable.set(format, ok);
+    return ok;
+  }
+
+  /** Every format this host could actually encode, for error messages. */
+  async encodableFormats(): Promise<string[]> {
+    const all: ConversionFormat[] = ["jpeg", "png", "webp", "avif", "heic"];
+    const available: string[] = [];
+    for (const format of all) {
+      if (await this.canEncode(format)) available.push(format);
+    }
+    return available;
+  }
+}
+
+/** Select the output encoder on a pipeline. */
+function _applyFormat(
+  pipeline: Bun.Image,
+  format: ConversionFormat,
+  quality: number | undefined,
+): Bun.Image {
+  switch (format) {
+    case "jpeg":
+      return quality === undefined ? pipeline.jpeg() : pipeline.jpeg({ quality });
+    case "webp":
+      return quality === undefined ? pipeline.webp() : pipeline.webp({ quality });
+    case "avif":
+      return quality === undefined ? pipeline.avif() : pipeline.avif({ quality });
+    case "heic":
+      return quality === undefined ? pipeline.heic() : pipeline.heic({ quality });
+    case "png":
+      // PNG is lossless: it takes a zlib level, not a quality. Mapping 1–100
+      // onto 0–9 would make `quality: 82` mean something quite different here
+      // than it does for JPEG, so the default level is used instead.
+      return pipeline.png();
+  }
+}
+
+/** The stable `error.code` Bun.Image sets, when there is one. */
+function _codeOf(error: unknown): string | undefined {
+  if (typeof error !== "object" || error === null) return undefined;
+  const code = (error as { code?: unknown }).code;
+  return typeof code === "string" ? code : undefined;
+}
+
+/** A valid 2×2 PNG, used to probe which encoders this host actually has. */
+const _PROBE_PNG = Uint8Array.from(
+  atob(
+    "iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAYAAABytg0kAAAAD0lEQVR4nGMsY2AoY0AGAA5uAO6e" +
+      "5/phAAAAAElFTkSuQmCC",
+  ),
+  (c) => c.charCodeAt(0),
+);

package/src/conversions/ConversionRunner.ts

@@ -0,0 +1,219 @@
+import {
+  FORMAT_EXTENSION,
+  isConvertible,
+  type ImageDriver,
+  type ImageManipulation,
+} from "./ImageDriver.ts";
+import { UnsupportedFormatError } from "../errors.ts";
+import { pathGenerator, type MediaItem } from "../MediaItem.ts";
+import { diskFor } from "../support/disks.ts";
+import type { MediaConfigShape } from "../config.ts";
+import type {
+  ConversionDefinition,
+  ConversionFormat,
+  ConversionMap,
+  GeneratedConversion,
+  ResponsiveImage,
+  ResponsiveImageSet,
+  SafeConversionFormat,
+} from "../types.ts";
+
+/** Formats that encode on every host, whatever OS codecs it has. */
+const PORTABLE: ReadonlySet<string> = new Set<SafeConversionFormat>(["jpeg", "png", "webp"]);
+
+/** Which of a collection's conversions run now versus on the queue. */
+export function partitionConversions(
+  conversions: ConversionMap | undefined,
+  queueAvailable: boolean,
+): { inline: ConversionMap; queued: ConversionMap } {
+  const inline: ConversionMap = {};
+  const queued: ConversionMap = {};
+
+  for (const [name, definition] of Object.entries(conversions ?? {})) {
+    // Without a queue bound there is nowhere to defer to, so a conversion marked
+    // `queued` still runs — late is better than never, and an app with no queue
+    // would otherwise get silently empty thumbnails.
+    if (definition.queued === true && queueAvailable) queued[name] = definition;
+    else inline[name] = definition;
+  }
+
+  return { inline, queued };
+}
+
+/**
+ * Generates derived images and writes them next to their original.
+ *
+ * Failure of a single conversion is contained: the original is already stored
+ * and its row already exists, so a codec that chokes on one file should cost
+ * that file its thumbnail, not the upload. Failures are collected and returned
+ * rather than thrown.
+ */
+export class ConversionRunner {
+  constructor(
+    private readonly driver: ImageDriver,
+    private readonly config: MediaConfigShape,
+  ) {}
+
+  /**
+   * Run `conversions` against `media` and record what was generated.
+   *
+   * Mutates and saves the media row's `generated_conversions`. Returns the names
+   * that failed, with the reason, so a caller can log or surface them.
+   */
+  async run(
+    media: MediaItem,
+    conversions: ConversionMap,
+  ): Promise<{ generated: string[]; failed: Array<{ name: string; reason: string }> }> {
+    const generated: string[] = [];
+    const failed: Array<{ name: string; reason: string }> = [];
+
+    if (Object.keys(conversions).length === 0) return { generated, failed };
+    if (!isConvertible(media.mimeType)) return { generated, failed };
+
+    const source = await this.readSource(media);
+    if (source === null) return { generated, failed };
+
+    const metadata = await this.driver.metadata(source);
+    if (metadata === null) return { generated, failed };
+
+    const disk = diskFor(media.conversionsDisk ?? media.disk);
+    const directory = pathGenerator().forConversions(media);
+    const results: Record<string, GeneratedConversion> = { ...(media.generatedConversions ?? {}) };
+
+    for (const [name, definition] of Object.entries(conversions)) {
+      try {
+        const format = await this.resolveFormat(definition, metadata.format);
+        const manipulation = this.toManipulation(definition, format);
+        const result = await this.driver.convert(source, manipulation);
+
+        const fileName = `${name}.${FORMAT_EXTENSION[format]}`;
+        await disk.put(`${directory}/${fileName}`, result.bytes, {
+          contentType: result.mimeType,
+        });
+
+        results[name] = {
+          fileName,
+          size: result.bytes.byteLength,
+          mimeType: result.mimeType,
+          width: result.width,
+          height: result.height,
+          generatedAt: new Date().toISOString(),
+        };
+        generated.push(name);
+      } catch (error) {
+        failed.push({ name, reason: error instanceof Error ? error.message : String(error) });
+      }
+    }
+
+    if (generated.length > 0) {
+      media.generatedConversions = results;
+      await media.save();
+    }
+
+    return { generated, failed };
+  }
+
+  /**
+   * Generate the responsive width ladder plus an inline placeholder.
+   *
+   * Widths at or above the source's own width are skipped — upscaling produces a
+   * bigger file that looks worse, and a `srcset` entry claiming a width the
+   * pixels do not support makes the browser pick the wrong candidate.
+   */
+  async runResponsive(media: MediaItem, widths: number[]): Promise<ResponsiveImageSet | null> {
+    if (!isConvertible(media.mimeType)) return null;
+
+    const source = await this.readSource(media);
+    if (source === null) return null;
+
+    const metadata = await this.driver.metadata(source);
+    if (metadata === null) return null;
+
+    const disk = diskFor(media.conversionsDisk ?? media.disk);
+    const directory = pathGenerator().forResponsiveImages(media);
+    const format = await this.resolveFormat({}, metadata.format);
+    const images: ResponsiveImage[] = [];
+
+    for (const width of [...widths].sort((a, b) => a - b)) {
+      if (width > metadata.width) continue;
+      try {
+        const result = await this.driver.convert(source, {
+          width,
+          fit: "inside",
+          format,
+          quality: this.config.quality,
+          withoutEnlargement: true,
+        });
+        const fileName = `${width}.${FORMAT_EXTENSION[format]}`;
+        await disk.put(`${directory}/${fileName}`, result.bytes, {
+          contentType: result.mimeType,
+        });
+        images.push({ fileName, width: result.width, height: result.height });
+      } catch {
+        // One missing rung does not invalidate the ladder.
+      }
+    }
+
+    const set: ResponsiveImageSet = { images };
+
+    if (this.config.responsivePlaceholder) {
+      const placeholder = await this.driver.placeholder(source);
+      if (placeholder !== null) set.placeholder = placeholder;
+    }
+
+    if (images.length === 0 && set.placeholder === undefined) return null;
+
+    media.responsiveImages = set;
+    await media.save();
+    return set;
+  }
+
+  /** Read the original, refusing anything too large to decode safely. */
+  private async readSource(media: MediaItem): Promise<Uint8Array | null> {
+    if (media.size > this.config.maxConversionInputSize) return null;
+    try {
+      return await media.bytes();
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * The output format for one conversion.
+   *
+   * An explicit `format` wins but is verified against the host — asking for AVIF
+   * where no AV1 encoder exists is a configuration error worth reporting, not
+   * something to silently substitute. Otherwise the source format is kept when
+   * it is portable, and the configured default is used when it is not (a GIF or
+   * BMP source has no encoder at all, so it must change).
+   */
+  private async resolveFormat(
+    definition: ConversionDefinition,
+    sourceFormat: string,
+  ): Promise<ConversionFormat> {
+    if (definition.format !== undefined) {
+      const requested = definition.format;
+      if (!PORTABLE.has(requested) && !(await this.driver.canEncode(requested))) {
+        throw new UnsupportedFormatError(requested, [...PORTABLE]);
+      }
+      return requested;
+    }
+
+    if (PORTABLE.has(sourceFormat)) return sourceFormat as SafeConversionFormat;
+    return this.config.format;
+  }
+
+  private toManipulation(
+    definition: ConversionDefinition,
+    format: ConversionFormat,
+  ): ImageManipulation {
+    return {
+      ...(definition.width !== undefined ? { width: definition.width } : {}),
+      ...(definition.height !== undefined ? { height: definition.height } : {}),
+      ...(definition.rotate !== undefined ? { rotate: definition.rotate } : {}),
+      fit: definition.fit ?? "inside",
+      format,
+      quality: definition.quality ?? this.config.quality,
+    };
+  }
+}

package/src/conversions/ImageDriver.ts

@@ -0,0 +1,100 @@
+import type { ConversionFit, ConversionFormat } from "../types.ts";
+
+/** What a driver is asked to do to one image. */
+export interface ImageManipulation {
+  /** Target width. Omit both dimensions to re-encode without resizing. */
+  width?: number;
+  /** Target height. */
+  height?: number;
+  /** How to fit the source into the box. Default `"inside"`. */
+  fit?: ConversionFit;
+  /** Output format. Always resolved by the caller — drivers never guess. */
+  format: ConversionFormat;
+  /** Encoder quality 1–100. */
+  quality?: number;
+  /** Clockwise rotation in degrees, applied before resizing. */
+  rotate?: number;
+  /** Never scale a source up to meet the target box. Default `true`. */
+  withoutEnlargement?: boolean;
+}
+
+/** A generated image and what it turned out to be. */
+export interface ImageResult {
+  bytes: Uint8Array;
+  width: number;
+  height: number;
+  format: ConversionFormat;
+  mimeType: string;
+}
+
+/** What an image's header says it is. */
+export interface ImageMetadata {
+  width: number;
+  height: number;
+  format: string;
+}
+
+/**
+ * The seam between this package and whatever actually manipulates pixels.
+ *
+ * Two implementations ship: {@link BunImageDriver} (the default — no
+ * dependencies, no crop) and `SharpImageDriver` (opt-in, adds crop). Keeping
+ * both behind one interface is also what makes `Bun.Image` — which is a few
+ * weeks old — a safe thing to depend on: if its API moves, one file changes.
+ */
+export interface ImageDriver {
+  /** Name used in error messages. */
+  readonly name: string;
+  /** Whether `fit: "cover"` is available. */
+  readonly supportsCrop: boolean;
+
+  /** Read dimensions and format without decoding the whole image. */
+  metadata(bytes: Uint8Array): Promise<ImageMetadata | null>;
+
+  /** Apply a manipulation and return the encoded result. */
+  convert(bytes: Uint8Array, manipulation: ImageManipulation): Promise<ImageResult>;
+
+  /**
+   * A tiny inline `data:` URI of the image, for rendering while the real one
+   * loads. `null` when the driver cannot produce one.
+   */
+  placeholder(bytes: Uint8Array): Promise<string | null>;
+
+  /** Whether this host can encode `format`. */
+  canEncode(format: ConversionFormat): Promise<boolean>;
+}
+
+/** MIME type for each format a driver may emit. */
+export const FORMAT_MIME: Record<ConversionFormat, string> = {
+  jpeg: "image/jpeg",
+  png: "image/png",
+  webp: "image/webp",
+  avif: "image/avif",
+  heic: "image/heic",
+};
+
+/** File extension for each format. */
+export const FORMAT_EXTENSION: Record<ConversionFormat, string> = {
+  jpeg: "jpg",
+  png: "png",
+  webp: "webp",
+  avif: "avif",
+  heic: "heic",
+};
+
+/** MIME types this package will attempt to convert. */
+export const CONVERTIBLE_MIME_TYPES = new Set([
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "image/gif",
+  "image/avif",
+  "image/heic",
+  "image/bmp",
+  "image/tiff",
+]);
+
+/** Whether a stored file is worth handing to an image driver at all. */
+export function isConvertible(mimeType: string | null | undefined): boolean {
+  return mimeType !== null && mimeType !== undefined && CONVERTIBLE_MIME_TYPES.has(mimeType);
+}