@holo-js/media 0.1.4 → 0.1.6

package/dist/index.mjs

@@ -76,6 +76,9 @@ function getContentSize(value) {
   if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
     return value.byteLength;
   }
+  if (value instanceof ArrayBuffer) {
+    return value.byteLength;
+  }
   return value.size;
 }
 function isImageSource(mimeType, extension) {
@@ -269,7 +272,17 @@ function resolveMediaCollection(target, collectionName = "default") {
       acceptedExtensions: Object.freeze([])
     });
   }
-  return definition.collectionsByName[collectionName] ?? Object.freeze({
+  const collection2 = definition.collectionsByName[collectionName];
+  if (collection2) {
+    return collection2;
+  }
+  if (collectionName !== "default") {
+    const model = resolveDefinition(target);
+    throw new Error(
+      `[Holo Media] Unknown media collection "${collectionName}" for model "${model.name}".`
+    );
+  }
+  return Object.freeze({
     kind: "collection",
     name: collectionName,
     singleFile: false,
@@ -352,10 +365,13 @@ var Media = defineModel(mediaTable, {
 });
 
 // src/model/adder.ts
-import { basename as basename2 } from "path";
-import { readFile } from "fs/promises";
+import { isIP } from "net";
+import { tmpdir } from "os";
+import { basename as basename2, resolve, sep } from "path";
+import { readFile, realpath } from "fs/promises";
 import { randomUUID } from "crypto";
 import { Storage as Storage3 } from "@holo-js/storage/runtime";
+import { connectionAsyncContext as connectionAsyncContext4 } from "@holo-js/db";
 
 // src/queue.ts
 import {
@@ -364,10 +380,59 @@ import {
   getRegisteredQueueJob,
   registerQueueJob
 } from "@holo-js/queue";
-import { connectionAsyncContext } from "@holo-js/db";
+import { connectionAsyncContext as connectionAsyncContext2 } from "@holo-js/db";
 
 // src/model/conversions.ts
 import { Storage } from "@holo-js/storage/runtime";
+import { connectionAsyncContext } from "@holo-js/db";
+function getActiveTransaction() {
+  const active = connectionAsyncContext.getActive()?.connection;
+  if (!active || active.getScope().kind === "root") {
+    return void 0;
+  }
+  return active;
+}
+function registerStorageWriteRollback(snapshot) {
+  const active = getActiveTransaction();
+  if (!active) {
+    return;
+  }
+  active.afterRollback(async () => {
+    await restoreStoredFileSnapshot(snapshot);
+  });
+}
+async function restoreStoredFileSnapshot(snapshot) {
+  if (snapshot.contents) {
+    await Storage.disk(snapshot.disk).put(snapshot.path, snapshot.contents);
+    return;
+  }
+  await Storage.disk(snapshot.disk).delete(snapshot.path);
+}
+async function restoreStoredFileSnapshots(snapshots) {
+  for (const snapshot of [...snapshots].reverse()) {
+    await restoreStoredFileSnapshot(snapshot).catch(() => void 0);
+  }
+}
+async function putFileWithRollbackRestore(disk, path, contents) {
+  const previous = await Storage.disk(disk).getBytes(path);
+  await Storage.disk(disk).put(path, contents);
+  const snapshot = {
+    disk,
+    path,
+    contents: previous
+  };
+  registerStorageWriteRollback(snapshot);
+  return snapshot;
+}
+async function deleteFileWithRollbackRestore(disk, path) {
+  const previous = await Storage.disk(disk).getBytes(path);
+  await Storage.disk(disk).delete(path);
+  registerStorageWriteRollback({
+    disk,
+    path,
+    contents: previous
+  });
+}
 function fallbackCollectionDefinition(collectionName) {
   return Object.freeze({
     kind: "collection",
@@ -447,6 +512,7 @@ async function generateStoredConversions(options) {
   }
   const generatedConversions = /* @__PURE__ */ Object.create(null);
   const executor = getMediaConversionExecutor();
+  const writtenSnapshots = [];
   try {
     for (const conversion2 of matchingConversions) {
       const generated = await executor.generate({
@@ -469,7 +535,7 @@ async function generateStoredConversions(options) {
       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);
+      writtenSnapshots.push(await putFileWithRollbackRestore(targetDisk, conversionPath, conversionContents));
       generatedConversions[conversion2.name] = Object.freeze({
         path: conversionPath,
         disk: targetDisk,
@@ -479,19 +545,11 @@ async function generateStoredConversions(options) {
       });
     }
   } catch (error) {
-    await deleteStoredConversions(
-      generatedConversions,
-      options.conversionsDisk
-    );
+    await restoreStoredFileSnapshots(writtenSnapshots);
     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)) {
@@ -504,7 +562,7 @@ async function deleteObsoleteConversions(current, next, fallbackDisk, requested)
     if (nextConversion?.path === conversion2.path && nextConversion.disk === (conversion2.disk ?? fallbackDisk)) {
       continue;
     }
-    await Storage.disk(conversion2.disk ?? fallbackDisk).delete(conversion2.path);
+    await deleteFileWithRollbackRestore(conversion2.disk ?? fallbackDisk, conversion2.path);
   }
 }
 async function regenerateMediaEntityConversions(options) {
@@ -588,22 +646,30 @@ function normalizePayload(payload) {
 }
 async function runMediaGenerateConversionsJob(payload) {
   const normalized = normalizePayload(payload);
-  const media = await Media.find(normalized.mediaId);
-  if (!media) {
+  if (normalized.conversionNames.length === 0) {
     return Object.freeze({
-      status: "missing-media",
-      conversionNames: Object.freeze([])
+      status: "processed",
+      conversionNames: normalized.conversionNames
     });
   }
-  await regenerateMediaEntityConversions({
-    media,
-    conversions: normalized.conversionNames,
-    includeQueued: true
-  });
-  return Object.freeze({
-    status: "processed",
-    conversionNames: normalized.conversionNames
-  });
+  const media = typeof normalized.mediaId === "number" ? await Media.find(normalized.mediaId) : await Media.where("id", normalized.mediaId).first();
+  switch (media) {
+    case void 0:
+      return Object.freeze({
+        status: "missing-media",
+        conversionNames: Object.freeze([])
+      });
+    default:
+      await regenerateMediaEntityConversions({
+        media,
+        conversions: normalized.conversionNames,
+        includeQueued: true
+      });
+      return Object.freeze({
+        status: "processed",
+        conversionNames: normalized.conversionNames
+      });
+  }
 }
 function ensureMediaQueueJobRegistered() {
   if (getRegisteredQueueJob(MEDIA_GENERATE_CONVERSIONS_JOB)) {
@@ -618,8 +684,8 @@ function ensureMediaQueueJobRegistered() {
     name: MEDIA_GENERATE_CONVERSIONS_JOB
   });
 }
-function getActiveTransaction() {
-  const active = connectionAsyncContext.getActive()?.connection;
+function getActiveTransaction2() {
+  const active = connectionAsyncContext2.getActive()?.connection;
   if (!active || active.getScope().kind === "root") {
     return void 0;
   }
@@ -637,7 +703,7 @@ async function dispatchQueuedMediaConversions(payload) {
     return;
   }
   ensureMediaQueueJobRegistered();
-  const activeTransaction = getActiveTransaction();
+  const activeTransaction = getActiveTransaction2();
   if (activeTransaction) {
     activeTransaction.afterCommit(() => executeQueuedMediaDispatch(normalized));
     return;
@@ -650,7 +716,7 @@ async function dispatchQueuedMediaConversionsForModel(payload, onSynchronousDisp
     return;
   }
   ensureMediaQueueJobRegistered();
-  const activeTransaction = getActiveTransaction();
+  const activeTransaction = getActiveTransaction2();
   if (activeTransaction) {
     activeTransaction.afterCommit(() => executeQueuedMediaDispatch(normalized, onSynchronousDispatch));
     return;
@@ -660,6 +726,29 @@ async function dispatchQueuedMediaConversionsForModel(payload, onSynchronousDisp
 
 // src/model/item.ts
 import { Storage as Storage2 } from "@holo-js/storage/runtime";
+import { connectionAsyncContext as connectionAsyncContext3 } from "@holo-js/db";
+function toUrlPath(url) {
+  if (url.startsWith("/")) {
+    return url;
+  }
+  try {
+    const parsed = new URL(url);
+    return `${parsed.pathname}${parsed.search}`;
+  } catch {
+    return `/${url.replace(/^\/+/, "")}`;
+  }
+}
+function registerDeletedVariantRollbackRestore(snapshots) {
+  const active = connectionAsyncContext3.getActive()?.connection;
+  if (!active || active.getScope().kind === "root") {
+    return;
+  }
+  active.afterRollback(async () => {
+    for (const snapshot of [...snapshots].reverse()) {
+      await Storage2.disk(snapshot.disk).put(snapshot.path, snapshot.contents).catch(() => void 0);
+    }
+  });
+}
 var MediaItem = class {
   constructor(entity, owner) {
     this.entity = entity;
@@ -690,15 +779,8 @@ var MediaItem = class {
     );
   }
   getPath(conversion2) {
-    const variant = this.resolveVariant(conversion2);
-    if (!variant) {
-      return null;
-    }
-    try {
-      return Storage2.disk(variant.disk).path(variant.path);
-    } catch {
-      return null;
-    }
+    const url = this.getUrl(conversion2);
+    return url ? toUrlPath(url) : null;
   }
   getUrl(conversion2) {
     const variant = this.resolveVariant(conversion2);
@@ -737,6 +819,7 @@ var MediaItem = class {
         }
       }
       await this.entity.delete();
+      registerDeletedVariantRollbackRestore(deletedSnapshots);
       this.owner?.forgetRelation("media");
     } catch (error) {
       for (const snapshot of deletedSnapshots.reverse()) {
@@ -806,6 +889,20 @@ var MediaItem = class {
 };
 
 // src/model/adder.ts
+var DEFAULT_REMOTE_MEDIA_MAX_SIZE = 10 * 1024 * 1024;
+var LOCAL_MEDIA_SOURCE_ROOTS = Object.freeze([
+  tmpdir(),
+  resolve(process.cwd(), "storage")
+]);
+var MediaAddValidationException = class extends Error {
+  error;
+  constructor(details) {
+    const error = createMediaAddError(details);
+    super(error.message);
+    this.name = "MediaAddValidationException";
+    this.error = error;
+  }
+};
 function resolveImplicitDiskName() {
   const defaultDisk = Storage3.disk();
   if (defaultDisk.visibility === "public") {
@@ -828,14 +925,53 @@ function parseRemoteFileName(url) {
     return "media.bin";
   }
 }
-function createMaxSizeError(fileName, collectionName) {
-  return new Error(
-    `[Holo Media] File "${fileName}" exceeds the max size for collection "${collectionName}".`
-  );
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) {
+    return "0 bytes";
+  }
+  const units = ["bytes", "KB", "MB", "GB"];
+  let value = bytes;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  const formatted = unitIndex === 0 ? String(Math.round(value)) : value.toFixed(value >= 10 ? 0 : 1).replace(/\.0$/, "");
+  return `${formatted} ${units[unitIndex]}`;
+}
+function createMediaValidationMessage(details) {
+  if (details.code === "max_size_exceeded") {
+    return `The selected file must be ${formatBytes(details.maxSize)} or smaller.`;
+  }
+  if (details.code === "invalid_mime_type") {
+    return `The selected file must be one of these types: ${details.acceptedMimeTypes.join(", ")}.`;
+  }
+  return `The selected file must use one of these extensions: ${details.acceptedExtensions.join(", ")}.`;
+}
+function createMediaAddError(details) {
+  return Object.freeze({
+    ...details,
+    status: 422,
+    message: createMediaValidationMessage(details)
+  });
+}
+function createMaxSizeError(fileName, collectionName, maxSize, actualSize) {
+  return new MediaAddValidationException({
+    code: "max_size_exceeded",
+    collection: collectionName,
+    fileName,
+    maxSize,
+    actualSize
+  });
 }
 async function readRemoteMediaContents(response, fileName, maxSize, collectionName) {
-  if (typeof maxSize !== "number" || !response.body) {
-    return new Uint8Array(await response.arrayBuffer());
+  const resolvedMaxSize = typeof maxSize === "number" ? maxSize : DEFAULT_REMOTE_MEDIA_MAX_SIZE;
+  if (!response.body) {
+    const contents2 = new Uint8Array(await response.arrayBuffer());
+    if (contents2.byteLength > resolvedMaxSize) {
+      throw createMaxSizeError(fileName, collectionName ?? "default", resolvedMaxSize, contents2.byteLength);
+    }
+    return contents2;
   }
   const reader = response.body.getReader();
   const chunks = [];
@@ -850,9 +986,9 @@ async function readRemoteMediaContents(response, fileName, maxSize, collectionNa
         continue;
       }
       totalSize += value.byteLength;
-      if (totalSize > maxSize) {
+      if (totalSize > resolvedMaxSize) {
         await reader.cancel().catch(() => void 0);
-        throw createMaxSizeError(fileName, collectionName);
+        throw createMaxSizeError(fileName, collectionName ?? "default", resolvedMaxSize, totalSize);
       }
       chunks.push(value);
     }
@@ -887,7 +1023,7 @@ async function resolveMediaSource(input, overrideFileName, overrideName, options
     );
   }
   if (typeof input === "string" || isPathInput(input)) {
-    const path = typeof input === "string" ? input : input.path;
+    const path = await resolveLocalMediaSourcePath(typeof input === "string" ? input : input.path);
     const contents2 = await readFile(path);
     const fileName2 = sanitizeFileName(overrideFileName ?? basename2(path));
     return {
@@ -912,16 +1048,24 @@ async function resolveMediaSource(input, overrideFileName, overrideName, options
     };
   }
   const contents = await toBinaryContent(input);
-  const fileName = sanitizeFileName(overrideFileName ?? "media.bin");
+  const fileName = sanitizeFileName(overrideFileName ?? getBinaryFileName(input));
   return {
     contents,
     fileName,
-    mimeType: inferMimeType(fileName),
+    mimeType: inferMimeType(fileName, getBinaryMimeType(input)),
     extension: getExtension(fileName),
     size: getContentSize(contents),
     name: getDisplayName(fileName, overrideName)
   };
 }
+function getBinaryFileName(input) {
+  const name = input.name;
+  return typeof name === "string" && name.trim() ? name : "media.bin";
+}
+function getBinaryMimeType(input) {
+  const type = input.type;
+  return typeof type === "string" && type.trim() ? type : void 0;
+}
 function isPathInput(input) {
   return typeof input === "object" && input !== null && "path" in input;
 }
@@ -929,20 +1073,27 @@ 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);
+  const remoteUrl = resolveRemoteMediaUrl(input.url);
+  const response = await fetch(remoteUrl, {
+    redirect: "manual"
+  });
+  if (response.status >= 300 && response.status < 400) {
+    throw new Error("[@holo-js/media] Remote media downloads do not follow redirects.");
+  }
   if (!response.ok) {
     throw new Error(
-      `[Holo Media] Failed to download media from "${input.url}" (${response.status} ${response.statusText}).`
+      `[Holo Media] Failed to download media from "${remoteUrl}" (${response.status} ${response.statusText}).`
     );
   }
   const fileName = sanitizeFileName(
-    overrideFileName ?? input.fileName ?? parseRemoteFileName(input.url)
+    overrideFileName ?? input.fileName ?? parseRemoteFileName(remoteUrl)
   );
   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 resolvedMaxSize = typeof maxSize === "number" ? maxSize : DEFAULT_REMOTE_MEDIA_MAX_SIZE;
+  if (Number.isFinite(contentLength) && contentLength > resolvedMaxSize) {
+    throw createMaxSizeError(fileName, collectionName ?? "default", resolvedMaxSize, contentLength);
   }
   const contents = await readRemoteMediaContents(
     response,
@@ -959,25 +1110,75 @@ async function resolveRemoteMediaSource(input, overrideFileName, overrideName, m
     name: getDisplayName(fileName, overrideName ?? input.name)
   };
 }
+async function resolveLocalMediaSourcePath(path) {
+  const resolvedPath = await realpath(path);
+  const allowedRoots = await Promise.all(LOCAL_MEDIA_SOURCE_ROOTS.map(async (root) => await realpath(root).catch(() => null)));
+  if (allowedRoots.some((root) => root && isPathWithinRoot(resolvedPath, root))) {
+    return resolvedPath;
+  }
+  throw new Error("[@holo-js/media] Media path sources must resolve inside an allowed upload directory.");
+}
+function isPathWithinRoot(path, root) {
+  return path === root || path.startsWith(`${root}${sep}`);
+}
+function resolveRemoteMediaUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("[@holo-js/media] Remote media URLs must be valid absolute URLs.");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("[@holo-js/media] Remote media URLs must use http or https.");
+  }
+  if (url.username || url.password) {
+    throw new Error("[@holo-js/media] Remote media URLs must not include credentials.");
+  }
+  if (isBlockedRemoteMediaHost(url.hostname)) {
+    throw new Error("[@holo-js/media] Remote media URLs must not target local or private hosts.");
+  }
+  return url.toString();
+}
+function isBlockedRemoteMediaHost(hostname) {
+  const normalized = hostname.toLowerCase();
+  if (normalized === "localhost" || normalized.endsWith(".localhost")) {
+    return true;
+  }
+  const ipVersion = isIP(normalized);
+  if (ipVersion === 4) {
+    const [first = 0, second = 0] = normalized.split(".").map(Number);
+    return first === 0 || first === 10 || first === 127 || first === 169 && second === 254 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168 || first >= 224;
+  }
+  if (ipVersion === 6) {
+    return normalized === "::1" || normalized === "::" || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe80:");
+  }
+  return false;
+}
 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}".`
-    );
+    throw createMaxSizeError(source.fileName, collection2.name, collection2.maxSize, source.size);
   }
   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}".`
-      );
+      throw new MediaAddValidationException({
+        code: "invalid_mime_type",
+        collection: collection2.name,
+        fileName: source.fileName,
+        mimeType,
+        acceptedMimeTypes: collection2.acceptedMimeTypes
+      });
     }
   }
   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}".`
-      );
+      throw new MediaAddValidationException({
+        code: "invalid_extension",
+        collection: collection2.name,
+        fileName: source.fileName,
+        extension: source.extension,
+        acceptedExtensions: collection2.acceptedExtensions
+      });
     }
   }
 }
@@ -994,23 +1195,29 @@ async function deleteMediaItemsWithRollback(items) {
       deletedSnapshots.push(snapshot);
     }
   } catch (error) {
-    for (const snapshot of deletedSnapshots.reverse()) {
-      await restoreDeletedMediaSnapshot(snapshot).catch(() => void 0);
-    }
+    await restoreDeletedMediaSnapshots(deletedSnapshots);
     throw error;
   }
+  return deletedSnapshots;
 }
 async function deleteOverflowItems(items, limit) {
   if (items.length <= limit) {
-    return;
+    return [];
   }
-  await deleteMediaItemsWithRollback(items.slice(0, 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);
   }
 }
+function registerCreatedMediaRollbackCleanup(cleanup) {
+  const active = connectionAsyncContext4.getActive()?.connection;
+  if (!active || active.getScope().kind === "root") {
+    return;
+  }
+  active.afterRollback(cleanup);
+}
 async function snapshotDeletedMediaItem(item) {
   const record = item.record;
   const fileTargets = [{
@@ -1060,6 +1267,11 @@ async function restoreDeletedMediaSnapshot(snapshot) {
   }
   await Media.create(snapshot.record);
 }
+async function restoreDeletedMediaSnapshots(snapshots) {
+  for (const snapshot of snapshots.reverse()) {
+    await restoreDeletedMediaSnapshot(snapshot).catch(() => void 0);
+  }
+}
 var MediaAdder = class _MediaAdder {
   constructor(entity, source, state = {}) {
     this.entity = entity;
@@ -1085,6 +1297,23 @@ var MediaAdder = class _MediaAdder {
     });
   }
   async toMediaCollection(collectionName = "default") {
+    try {
+      const media = await this.storeInMediaCollection(collectionName);
+      return Object.assign(media, {
+        data: media,
+        error: null
+      });
+    } catch (error) {
+      if (error instanceof MediaAddValidationException) {
+        return {
+          data: null,
+          error: error.error
+        };
+      }
+      throw error;
+    }
+  }
+  async storeInMediaCollection(collectionName = "default") {
     const mediaDefinition = requireMediaDefinition(this.entity);
     const ownerDefinition = this.entity.getRepository().definition;
     const ownerId = this.entity.get(ownerDefinition.primaryKey);
@@ -1117,9 +1346,14 @@ var MediaAdder = class _MediaAdder {
     let originalStored = false;
     let createdMedia;
     let generatedConversions = Object.freeze({});
+    const deletedMediaSnapshots = [];
     try {
       await Storage3.disk(diskName).put(originalPath, source.contents);
       originalStored = true;
+      registerCreatedMediaRollbackCleanup(async () => {
+        await cleanupGeneratedConversions(generatedConversions, conversionsDisk).catch(() => void 0);
+        await Storage3.disk(diskName).delete(originalPath).catch(() => void 0);
+      });
       generatedConversions = await generateStoredConversions({
         definition: mediaDefinition,
         collection: collection2,
@@ -1155,10 +1389,10 @@ var MediaAdder = class _MediaAdder {
       });
       createdMedia = media;
       this.entity.forgetRelation("media");
-      await deleteMediaItemsWithRollback(existing);
+      deletedMediaSnapshots.push(...await deleteMediaItemsWithRollback(existing));
       if (typeof collection2.onlyKeepLatest === "number") {
         const items = await this.entity.getMedia(collectionName);
-        await deleteOverflowItems(items, collection2.onlyKeepLatest);
+        deletedMediaSnapshots.push(...await deleteOverflowItems(items, collection2.onlyKeepLatest));
       }
       const queuedConversions = resolveQueuedConversionNames({
         definition: mediaDefinition,
@@ -1180,6 +1414,7 @@ var MediaAdder = class _MediaAdder {
         await createdMedia.refresh().catch(() => void 0);
         await createdMedia.delete().catch(() => void 0);
       }
+      await restoreDeletedMediaSnapshots(deletedMediaSnapshots);
       this.entity.forgetRelation("media");
       throw error;
     }
@@ -1286,6 +1521,12 @@ function installEntityMediaMethods() {
 import { morphMany } from "@holo-js/db";
 
 // src/definitions/collections.ts
+function normalizePositiveInteger(value, fieldName) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`[Holo Media] Media collection ${fieldName} must be a finite number.`);
+  }
+  return Math.max(1, Math.floor(value));
+}
 function decorateCollection(definition) {
   const clone = (overrides) => decorateCollection(Object.freeze({
     ...definition,
@@ -1306,7 +1547,7 @@ function decorateCollection(definition) {
     },
     onlyKeepLatest(limit) {
       return clone({
-        onlyKeepLatest: Math.max(1, Math.floor(limit))
+        onlyKeepLatest: normalizePositiveInteger(limit, "onlyKeepLatest")
       });
     },
     acceptsMimeTypes(mimeTypes) {
@@ -1325,7 +1566,7 @@ function decorateCollection(definition) {
     },
     maxSize(bytes) {
       return clone({
-        maxFileSize: Math.max(1, Math.floor(bytes))
+        maxFileSize: normalizePositiveInteger(bytes, "maxFileSize")
       });
     }
   });
@@ -1346,19 +1587,31 @@ function normalizeCollectionDefinitions(definitions) {
       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,
+      onlyKeepLatest: typeof definition.onlyKeepLatest === "number" ? normalizePositiveInteger(definition.onlyKeepLatest, "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
+      maxSize: typeof definition.maxFileSize === "number" ? normalizePositiveInteger(definition.maxFileSize, "maxFileSize") : void 0
     });
   }));
 }
 
 // src/definitions/conversions.ts
+function normalizePositiveInteger2(value, fieldName) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`[Holo Media] Media conversion ${fieldName} must be a finite number.`);
+  }
+  return Math.max(1, Math.floor(value));
+}
+function normalizeQuality(value) {
+  if (!Number.isFinite(value)) {
+    throw new Error("[Holo Media] Media conversion quality must be a finite number.");
+  }
+  return Math.max(1, Math.min(100, Math.floor(value)));
+}
 function decorateConversion(definition) {
   const clone = (overrides) => decorateConversion(Object.freeze({
     ...definition,
@@ -1377,12 +1630,12 @@ function decorateConversion(definition) {
     },
     width(pixels) {
       return clone({
-        width: Math.max(1, Math.floor(pixels))
+        width: normalizePositiveInteger2(pixels, "width")
       });
     },
     height(pixels) {
       return clone({
-        height: Math.max(1, Math.floor(pixels))
+        height: normalizePositiveInteger2(pixels, "height")
       });
     },
     fit(mode) {
@@ -1393,7 +1646,7 @@ function decorateConversion(definition) {
     },
     quality(value) {
       return clone({
-        quality: Math.max(1, Math.min(100, Math.floor(value)))
+        quality: normalizeQuality(value)
       });
     },
     queued() {
@@ -1419,9 +1672,9 @@ function normalizeConversionDefinitions(definitions) {
       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,
+      width: typeof definition.width === "number" ? normalizePositiveInteger2(definition.width, "width") : void 0,
+      height: typeof definition.height === "number" ? normalizePositiveInteger2(definition.height, "height") : void 0,
+      quality: typeof definition.quality === "number" ? normalizeQuality(definition.quality) : void 0,
       queued: Boolean(definition.queued)
     });
   }));