@holo-js/media 0.1.4 → 0.1.5

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,
@@ -356,6 +369,7 @@ import { basename as basename2 } from "path";
 import { readFile } 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 +378,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 +510,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 +533,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 +543,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 +560,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 +644,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 +682,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 +701,7 @@ async function dispatchQueuedMediaConversions(payload) {
     return;
   }
   ensureMediaQueueJobRegistered();
-  const activeTransaction = getActiveTransaction();
+  const activeTransaction = getActiveTransaction2();
   if (activeTransaction) {
     activeTransaction.afterCommit(() => executeQueuedMediaDispatch(normalized));
     return;
@@ -650,7 +714,7 @@ async function dispatchQueuedMediaConversionsForModel(payload, onSynchronousDisp
     return;
   }
   ensureMediaQueueJobRegistered();
-  const activeTransaction = getActiveTransaction();
+  const activeTransaction = getActiveTransaction2();
   if (activeTransaction) {
     activeTransaction.afterCommit(() => executeQueuedMediaDispatch(normalized, onSynchronousDispatch));
     return;
@@ -660,6 +724,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 +777,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 +817,7 @@ var MediaItem = class {
         }
       }
       await this.entity.delete();
+      registerDeletedVariantRollbackRestore(deletedSnapshots);
       this.owner?.forgetRelation("media");
     } catch (error) {
       for (const snapshot of deletedSnapshots.reverse()) {
@@ -806,6 +887,15 @@ var MediaItem = class {
 };
 
 // src/model/adder.ts
+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,10 +918,44 @@ 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) {
@@ -852,7 +976,7 @@ async function readRemoteMediaContents(response, fileName, maxSize, collectionNa
       totalSize += value.byteLength;
       if (totalSize > maxSize) {
         await reader.cancel().catch(() => void 0);
-        throw createMaxSizeError(fileName, collectionName);
+        throw createMaxSizeError(fileName, collectionName ?? "default", maxSize, totalSize);
       }
       chunks.push(value);
     }
@@ -912,16 +1036,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;
 }
@@ -942,7 +1074,7 @@ async function resolveRemoteMediaSource(input, overrideFileName, overrideName, m
   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);
+    throw createMaxSizeError(fileName, collectionName ?? "default", maxSize, contentLength);
   }
   const contents = await readRemoteMediaContents(
     response,
@@ -961,23 +1093,29 @@ async function resolveRemoteMediaSource(input, overrideFileName, overrideName, m
 }
 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 +1132,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 +1204,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 +1234,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 +1283,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 +1326,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 +1351,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 +1458,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 +1484,7 @@ function decorateCollection(definition) {
     },
     onlyKeepLatest(limit) {
       return clone({
-        onlyKeepLatest: Math.max(1, Math.floor(limit))
+        onlyKeepLatest: normalizePositiveInteger(limit, "onlyKeepLatest")
       });
     },
     acceptsMimeTypes(mimeTypes) {
@@ -1325,7 +1503,7 @@ function decorateCollection(definition) {
     },
     maxSize(bytes) {
       return clone({
-        maxFileSize: Math.max(1, Math.floor(bytes))
+        maxFileSize: normalizePositiveInteger(bytes, "maxFileSize")
       });
     }
   });
@@ -1346,19 +1524,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 +1567,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 +1583,7 @@ function decorateConversion(definition) {
     },
     quality(value) {
       return clone({
-        quality: Math.max(1, Math.min(100, Math.floor(value)))
+        quality: normalizeQuality(value)
       });
     },
     queued() {
@@ -1419,9 +1609,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)
     });
   }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/media",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Holo-JS Framework - media collections and conversions for Holo-JS models",
   "type": "module",
   "license": "MIT",
@@ -16,20 +16,20 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun x tsup",
-    "stub": "bun x tsup",
+    "build": "tsup",
+    "stub": "tsup",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/db": "^0.1.4",
-    "@holo-js/queue": "^0.1.4",
-    "@holo-js/storage": "^0.1.4",
+    "@holo-js/db": "^0.1.5",
+    "@holo-js/queue": "^0.1.5",
+    "@holo-js/storage": "^0.1.5",
     "sharp": "^0.34.4"
   },
   "devDependencies": {
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.5"
   }
 }