@holo-js/media 0.3.16 → 0.3.18

package/dist/index.d.ts

@@ -185,7 +185,7 @@ declare const Media: _holo_js_db.StaticModelApi<_holo_js_db.BoundTableDefinition
     updated_at: _holo_js_db.ColumnBuilder<Date, false, true, false, false>;
 }>, _holo_js_db.EmptyScopeMap, {
     model: _holo_js_db.MorphToRelationDefinition<_holo_js_db.TableDefinition<string, _holo_js_db.TableColumnsShape>>;
-}>;
+}, readonly string[]>;
 
 type MediaRecord = ModelRecord<typeof Media.definition.table>;
 declare class MediaItem<TCollectionName extends string = string, TConversionName extends string = string, TEntity extends Entity<TableDefinition> = Entity<TableDefinition>> {
@@ -209,7 +209,6 @@ declare class MediaItem<TCollectionName extends string = string, TConversionName
     regenerate(conversions?: TConversionName | readonly TConversionName[]): Promise<this>;
     toJSON(): MediaRecord;
     private resolveVariant;
-    private resolveStoredVariants;
 }
 
 type MediaSourceInput = string | BinaryContent | {
@@ -368,5 +367,14 @@ declare function dispatchQueuedMediaConversions(payload: MediaGenerateConversion
 
 declare function createDefaultMediaConversionExecutor(): MediaConversionExecutor;
 declare const defaultMediaConversionExecutor: MediaConversionExecutor;
+interface MediaImageInspection {
+    readonly mimeType: 'image/gif' | 'image/jpeg' | 'image/png' | 'image/webp';
+    readonly width: number;
+    readonly height: number;
+    readonly pages: number;
+}
+declare const mediaRuntimeInternals: Readonly<{
+    inspectImage(contents: Uint8Array, maximumPixels?: number): Promise<MediaImageInspection>;
+}>;
 
-export { type CollectionNamesOf, type ConversionNamesOf, MEDIA_GENERATE_CONVERSIONS_JOB, Media, type MediaAddResult, MediaAdder, type MediaCollectionBuilder, type MediaCollectionDefinition, type MediaConversionBuilder, type MediaConversionDefinition, type MediaConversionExecutor, type MediaConversionExecutorInput, type MediaConversionExecutorResult, type MediaConversionExecutorSource, type MediaConversionFit, type MediaConversionFormat, type MediaConversionPathInput, type MediaDefinitionFactory, type MediaDefinitionHelpers, type MediaDefinitionInput, type MediaEnabledEntity, type MediaEnabledModel, type MediaGenerateConversionsPayload, type MediaGenerateConversionsResult, MediaItem, type MediaOriginalPathInput, type MediaPathGenerator, type MediaSourceInput, type NormalizedMediaCollectionDefinition, type NormalizedMediaConversionDefinition, type NormalizedMediaDefinition, type StoredMediaConversion, 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 };
+export { type CollectionNamesOf, type ConversionNamesOf, MEDIA_GENERATE_CONVERSIONS_JOB, Media, type MediaAddResult, MediaAdder, type MediaCollectionBuilder, type MediaCollectionDefinition, type MediaConversionBuilder, type MediaConversionDefinition, type MediaConversionExecutor, type MediaConversionExecutorInput, type MediaConversionExecutorResult, type MediaConversionExecutorSource, type MediaConversionFit, type MediaConversionFormat, type MediaConversionPathInput, type MediaDefinitionFactory, type MediaDefinitionHelpers, type MediaDefinitionInput, type MediaEnabledEntity, type MediaEnabledModel, type MediaGenerateConversionsPayload, type MediaGenerateConversionsResult, MediaItem, type MediaOriginalPathInput, type MediaPathGenerator, type MediaSourceInput, type NormalizedMediaCollectionDefinition, type NormalizedMediaConversionDefinition, type NormalizedMediaDefinition, type StoredMediaConversion, collection, conversion, createDefaultMediaConversionExecutor, defaultMediaConversionExecutor, defineMediaModel, dispatchQueuedMediaConversions, ensureMediaQueueJobRegistered, getMediaConversionExecutor, getMediaDefinition, getMediaDefinitionForMorphClass, getMediaPathGenerator, mediaRuntimeInternals, normalizeCollectionDefinitions, normalizeConversionDefinitions, normalizeMediaDefinition, registerMediaDefinition, requireMediaDefinition, requireMediaDefinitionForMorphClass, resetMediaPathGenerator, resetMediaRuntime, resolveMediaCollection, resolveMediaConversion, resolveMediaDefinition, runMediaGenerateConversionsJob, setMediaConversionExecutor, setMediaPathGenerator };

package/dist/index.mjs

@@ -110,10 +110,7 @@ function replaceFileExtension(fileName, 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 ??= import("sharp").then((module) => module.default).catch((error) => {
     sharpFactoryPromise = void 0;
     throw error;
   });
@@ -195,6 +192,30 @@ function createDefaultMediaConversionExecutor() {
   };
 }
 var defaultMediaConversionExecutor = createDefaultMediaConversionExecutor();
+var imageMimeTypes = {
+  gif: "image/gif",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  webp: "image/webp"
+};
+var mediaRuntimeInternals = Object.freeze({
+  async inspectImage(contents, maximumPixels = 4e7) {
+    if (!Number.isSafeInteger(maximumPixels) || maximumPixels < 1) throw new TypeError("[Holo Media] Image pixel limits require a positive integer.");
+    const factory = await loadSharp();
+    try {
+      const image = factory(Buffer.from(contents), { animated: true, failOn: "warning", limitInputPixels: maximumPixels });
+      const metadata = await image.metadata();
+      const { width, height } = metadata;
+      const format = metadata.format;
+      if (format !== "gif" && format !== "jpeg" && format !== "png" && format !== "webp") throw new Error("[Holo Media] Unsupported raster image format.");
+      if (!width || !height || !Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width * height > maximumPixels) throw new Error("[Holo Media] Image exceeds the pixel limit.");
+      await image.stats();
+      return { mimeType: imageMimeTypes[format], width, height: metadata.pageHeight ?? height, pages: metadata.pages ?? 1 };
+    } catch (error) {
+      throw new Error("[Holo Media] Image could not be decoded.", { cause: error });
+    }
+  }
+});
 
 // src/registry.ts
 var mediaRegistrySymbol = /* @__PURE__ */ Symbol.for("@holo-js/media.registry");
@@ -384,8 +405,7 @@ import { BlockList, isIP } from "net";
 import { tmpdir } from "os";
 import { basename as basename2, resolve, sep } from "path";
 import { Readable } from "stream";
-import { Storage as Storage3 } from "@holo-js/storage/runtime";
-import { connectionAsyncContext as connectionAsyncContext4 } from "@holo-js/db";
+import { Storage as Storage4 } from "@holo-js/storage/runtime";
 
 // src/queue.ts
 import {
@@ -394,59 +414,114 @@ import {
   getRegisteredQueueJob,
   registerQueueJob
 } from "@holo-js/queue";
-import { connectionAsyncContext as connectionAsyncContext2 } from "@holo-js/db";
+import { connectionAsyncContext } from "@holo-js/db";
 
 // src/model/conversions.ts
+import { Storage as Storage2 } from "@holo-js/storage/runtime";
+
+// src/model/mutation.ts
+import { DB } from "@holo-js/db";
 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;
+var MediaMutation = class {
+  written = [];
+  async put(disk, path, contents) {
+    const previous = await Storage.disk(disk).getBytes(path);
+    this.written.push({ disk, path, previous });
+    await Storage.disk(disk).put(path, contents);
+  }
+  async compensate() {
+    const failures = [];
+    for (const file of this.written.splice(0).reverse()) {
+      try {
+        if (file.previous) {
+          await Storage.disk(file.disk).put(file.path, file.previous);
+        } else {
+          await Storage.disk(file.disk).delete(file.path);
+        }
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1) throw new AggregateError(failures, "[Holo Media] File compensation failed.");
   }
-  active.afterRollback(async () => {
-    await restoreStoredFileSnapshot(snapshot);
+};
+async function runMediaMutation(options) {
+  const mutation = new MediaMutation();
+  return await DB.writeTransaction(async (transaction) => {
+    transaction.afterRollback(async () => {
+      const failures = [];
+      try {
+        await mutation.compensate();
+      } catch (error) {
+        failures.push(error);
+      }
+      try {
+        await options.afterRollback?.();
+      } catch (error) {
+        failures.push(error);
+      }
+      if (failures.length === 1) throw failures[0];
+      if (failures.length > 1) throw new AggregateError(failures, "[Holo Media] Rollback restoration failed.");
+    });
+    const result = await options.operation(mutation);
+    transaction.afterCommit(async () => {
+      const failures = [];
+      for (const effect of options.afterCommit ?? []) {
+        try {
+          await effect(result);
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+      options.afterEffects?.();
+      if (failures.length === 0) return;
+      const cause = failures.length === 1 ? failures[0] : new AggregateError(failures, "[Holo Media] Post-commit effects failed.");
+      throw new Error(options.committedMessage, { cause });
+    });
+    return result;
   });
 }
-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 removeStoredFiles(files, retained = []) {
+  const failures = [];
+  for (const file of files) {
+    if (retained.some((current) => current.disk === file.disk && current.path === file.path)) continue;
+    try {
+      await Storage.disk(file.disk).delete(file.path);
+    } catch (error) {
+      failures.push(error);
+    }
   }
+  if (failures.length === 1) throw failures[0];
+  if (failures.length > 1) throw new AggregateError(failures, "[Holo Media] Obsolete-file cleanup failed.");
 }
-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
+async function removeObsoleteFiles(items, retained) {
+  await removeStoredFiles(items.flatMap(({ record }) => [
+    { disk: record.disk, path: record.path },
+    ...Object.values(record.generated_conversions ?? {}).filter((conversion2) => conversion2?.path).map((conversion2) => ({
+      disk: conversion2.disk ?? record.conversions_disk ?? record.disk,
+      path: conversion2.path
+    }))
+  ]), retained);
+}
+async function deleteMediaItems(items, owner) {
+  if (items.length === 0) return;
+  await runMediaMutation({
+    committedMessage: "[Holo Media] Deletion remains committed; post-commit file cleanup failed.",
+    operation: async () => {
+      for (const item of items) await item.getEntity().delete();
+      owner?.forgetRelation("media");
+    },
+    afterRollback: () => {
+      owner?.forgetRelation("media");
+    },
+    afterCommit: [async () => {
+      await removeObsoleteFiles(items, []);
+    }]
   });
 }
+
+// src/model/conversions.ts
 function fallbackCollectionDefinition(collectionName) {
   return Object.freeze({
     kind: "collection",
@@ -526,58 +601,45 @@ 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({
-        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);
-      writtenSnapshots.push(await putFileWithRollbackRestore(targetDisk, conversionPath, conversionContents));
-      generatedConversions[conversion2.name] = Object.freeze({
-        path: conversionPath,
-        disk: targetDisk,
-        fileName: generatedFileName,
-        mimeType: conversionMimeType,
-        size: getContentSize(conversionContents)
-      });
+  for (const conversion2 of matchingConversions) {
+    const generated = await executor.generate({
+      source: options.source,
+      collection: options.collection,
+      conversion: conversion2
+    });
+    if (!generated) {
+      continue;
     }
-  } catch (error) {
-    await restoreStoredFileSnapshots(writtenSnapshots);
-    throw error;
+    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 options.mutation.put(targetDisk, conversionPath, conversionContents);
+    generatedConversions[conversion2.name] = Object.freeze({
+      path: conversionPath,
+      disk: targetDisk,
+      fileName: generatedFileName,
+      mimeType: conversionMimeType,
+      size: getContentSize(conversionContents)
+    });
   }
   return Object.freeze(generatedConversions);
 }
 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 obsolete = Object.entries(current).filter(([name, conversion2]) => {
+    if (requested?.length && !requested.includes(name) || !conversion2?.path) return false;
     const nextConversion = next[name];
-    if (nextConversion?.path === conversion2.path && nextConversion.disk === (conversion2.disk ?? fallbackDisk)) {
-      continue;
-    }
-    await deleteFileWithRollbackRestore(conversion2.disk ?? fallbackDisk, conversion2.path);
-  }
+    return nextConversion?.path !== conversion2.path || (nextConversion.disk ?? fallbackDisk) !== (conversion2.disk ?? fallbackDisk);
+  }).map(([, conversion2]) => ({ disk: conversion2.disk ?? fallbackDisk, path: conversion2.path }));
+  await removeStoredFiles(obsolete);
 }
 async function regenerateMediaEntityConversions(options) {
   const media = options.media;
@@ -591,7 +653,7 @@ async function regenerateMediaEntityConversions(options) {
   resolveMatchingConversions(definition, collectionName, requested, {
     includeQueued: options.includeQueued === true
   });
-  const sourceContents = await Storage.disk(String(media.get("disk"))).getBytes(String(media.get("path")));
+  const sourceContents = await Storage2.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.`
@@ -600,32 +662,53 @@ async function regenerateMediaEntityConversions(options) {
   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
+  return await runMediaMutation({
+    committedMessage: "[Holo Media] Regeneration remains committed; post-commit cleanup or conversion dispatch failed.",
+    afterRollback: async () => {
+      options.owner?.forgetRelation("media");
+      await media.refresh();
+    },
+    operation: async (mutation) => {
+      const regenerated = await generateStoredConversions({
+        definition,
+        collection: collection2,
+        conversionsDisk,
+        requestedConversions: requested,
+        includeQueued: options.includeQueued === true,
+        mutation,
+        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();
+      options.owner?.forgetRelation("media");
+      return generatedConversions;
+    },
+    afterCommit: [
+      async (generatedConversions) => {
+        await deleteObsoleteConversions(current, generatedConversions, conversionsDisk, requested);
+      },
+      async () => {
+        if (options.includeQueued) return;
+        await dispatchQueuedMediaConversionsForModel({
+          mediaId: media.get("id"),
+          conversionNames: resolveQueuedConversionNames({ definition, collectionName, requestedConversions: requested })
+        }, async () => {
+          await media.refresh();
+        });
+      }
+    ],
+    afterEffects: () => {
+      options.owner?.forgetRelation("media");
     }
   });
-  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
@@ -698,8 +781,8 @@ function ensureMediaQueueJobRegistered() {
     name: MEDIA_GENERATE_CONVERSIONS_JOB
   });
 }
-function getActiveTransaction2() {
-  const active = connectionAsyncContext2.getActive()?.connection;
+function getActiveTransaction() {
+  const active = connectionAsyncContext.getActive()?.connection;
   if (!active || active.getScope().kind === "root") {
     return void 0;
   }
@@ -717,7 +800,7 @@ async function dispatchQueuedMediaConversions(payload) {
     return;
   }
   ensureMediaQueueJobRegistered();
-  const activeTransaction = getActiveTransaction2();
+  const activeTransaction = getActiveTransaction();
   if (activeTransaction) {
     activeTransaction.afterCommit(() => executeQueuedMediaDispatch(normalized));
     return;
@@ -730,7 +813,7 @@ async function dispatchQueuedMediaConversionsForModel(payload, onSynchronousDisp
     return;
   }
   ensureMediaQueueJobRegistered();
-  const activeTransaction = getActiveTransaction2();
+  const activeTransaction = getActiveTransaction();
   if (activeTransaction) {
     activeTransaction.afterCommit(() => executeQueuedMediaDispatch(normalized, onSynchronousDispatch));
     return;
@@ -739,8 +822,7 @@ 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";
+import { Storage as Storage3 } from "@holo-js/storage/runtime";
 function toUrlPath(url) {
   if (url.startsWith("/")) {
     return url;
@@ -752,17 +834,6 @@ function toUrlPath(url) {
     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;
@@ -802,7 +873,7 @@ var MediaItem = class {
       return null;
     }
     try {
-      return Storage2.disk(variant.disk).url(variant.path);
+      return Storage3.disk(variant.disk).url(variant.path);
     } catch {
       return null;
     }
@@ -813,34 +884,13 @@ var MediaItem = class {
       return null;
     }
     try {
-      return Storage2.disk(variant.disk).temporaryUrl(variant.path, options);
+      return Storage3.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();
-      registerDeletedVariantRollbackRestore(deletedSnapshots);
-      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;
-    }
+    await deleteMediaItems([this], this.owner);
   }
   async regenerate(conversions) {
     await regenerateMediaEntityConversions({
@@ -848,18 +898,6 @@ var MediaItem = class {
       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() {
@@ -882,24 +920,6 @@ var MediaItem = class {
       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
@@ -931,12 +951,12 @@ var MediaAddValidationException = class extends Error {
   }
 };
 function resolveImplicitDiskName() {
-  const defaultDisk = Storage3.disk();
+  const defaultDisk = Storage4.disk();
   if (defaultDisk.visibility === "public") {
     return defaultDisk.name;
   }
   try {
-    const publicDisk = Storage3.disk("public");
+    const publicDisk = Storage4.disk("public");
     if (publicDisk.visibility === "public") {
       return publicDisk.name;
     }
@@ -1269,96 +1289,6 @@ function validateSource(collection2, source) {
     }
   }
 }
-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) {
-    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));
-}
-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 = [{
-    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);
-}
-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;
@@ -1420,93 +1350,93 @@ var MediaAdder = class _MediaAdder {
       }
     );
     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
+    return await attachMedia({
+      owner: this.entity,
+      collectionName,
+      collection: collection2,
+      definition: mediaDefinition,
+      source,
+      disk: this.state.disk ?? collection2.disk ?? resolveImplicitDiskName()
     });
-    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,
+  }
+};
+async function attachMedia(options) {
+  const { owner, collection: collection2, source, disk } = options;
+  const ownerDefinition = owner.getRepository().definition;
+  const ownerId = String(owner.get(ownerDefinition.primaryKey));
+  const uuid = randomUUID();
+  const conversionsDisk = collection2.conversionsDisk ?? disk;
+  const path = getMediaPathGenerator().originalPath({ uuid, fileName: source.fileName, extension: source.extension, collection: collection2 });
+  const obsolete = [];
+  return await runMediaMutation({
+    committedMessage: "[Holo Media] Attachment remains committed; post-commit cleanup or conversion dispatch failed.",
+    afterRollback: () => {
+      owner.forgetRelation("media");
+    },
+    operation: async (mutation) => {
+      const existing = collection2.singleFile ? await owner.getMedia(options.collectionName) : [];
+      await mutation.put(disk, path, source.contents);
+      const generatedConversions = await generateStoredConversions({
+        definition: options.definition,
         collection: collection2,
         conversionsDisk,
-        source: {
-          uuid,
-          fileName: source.fileName,
-          extension: source.extension,
-          mimeType: source.mimeType,
-          size: source.size,
-          contents: source.contents
-        }
+        source: { ...source, uuid },
+        mutation
       });
+      const max = await Media.query().where("model_type", ownerDefinition.morphClass).where("model_id", ownerId).where("collection_name", options.collectionName).max("order_column");
       const media = await Media.create({
         uuid,
         model_type: ownerDefinition.morphClass,
-        model_id: String(ownerId),
-        collection_name: collectionName,
+        model_id: ownerId,
+        collection_name: options.collectionName,
         name: source.name,
         file_name: source.fileName,
-        disk: diskName,
+        disk,
         conversions_disk: conversionsDisk,
         mime_type: source.mimeType ?? null,
         extension: source.extension ?? null,
         size: source.size,
-        path: originalPath,
+        path,
         generated_conversions: generatedConversions,
-        order_column: await resolveNextOrderColumn(
-          ownerDefinition.morphClass,
-          String(ownerId),
-          collectionName
-        )
+        order_column: (max ?? 0) + 1
       });
-      createdMedia = media;
-      this.entity.forgetRelation("media");
-      deletedMediaSnapshots.push(...await deleteMediaItemsWithRollback(existing));
+      for (const item of existing) await item.getEntity().delete();
+      owner.forgetRelation("media");
+      obsolete.push(...existing);
       if (typeof collection2.onlyKeepLatest === "number") {
-        const items = await this.entity.getMedia(collectionName);
-        deletedMediaSnapshots.push(...await deleteOverflowItems(items, collection2.onlyKeepLatest));
+        const items = await owner.getMedia(options.collectionName);
+        const overflow = items.slice(0, Math.max(0, items.length - collection2.onlyKeepLatest));
+        for (const item of overflow) await item.getEntity().delete();
+        obsolete.push(...overflow);
+        owner.forgetRelation("media");
       }
-      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);
+      return new MediaItem(media, owner);
+    },
+    afterCommit: [
+      async (item) => {
+        await removeObsoleteFiles(obsolete, [
+          { disk, path },
+          ...Object.values(item.record.generated_conversions).map((conversion2) => ({
+            disk: conversion2.disk ?? conversionsDisk,
+            path: conversion2.path
+          }))
+        ]);
+      },
+      async (item) => {
+        const media = item.getEntity();
+        await dispatchQueuedMediaConversionsForModel({
+          mediaId: media.get("id"),
+          conversionNames: resolveQueuedConversionNames({ definition: options.definition, collectionName: collection2.name })
+        }, async () => {
+          await media.refresh();
+        });
       }
-      await restoreDeletedMediaSnapshots(deletedMediaSnapshots);
-      this.entity.forgetRelation("media");
-      throw error;
+    ],
+    afterEffects: () => {
+      owner.forgetRelation("media");
     }
-  }
-};
+  });
+}
 
 // src/model/entity.ts
 async function clearEntityMedia(entity, collectionName) {
@@ -1515,9 +1445,7 @@ async function clearEntityMedia(entity, collectionName) {
     return;
   }
   const rows = await query.get();
-  for (const row of rows) {
-    await new MediaItem(row, entity).delete();
-  }
+  await deleteMediaItems(rows.map((row) => new MediaItem(row, entity)), entity);
 }
 function getOwnerKey(entity) {
   const ownerDefinition = entity.getRepository().definition;
@@ -1872,6 +1800,7 @@ export {
   getMediaDefinition,
   getMediaDefinitionForMorphClass,
   getMediaPathGenerator,
+  mediaRuntimeInternals,
   normalizeCollectionDefinitions,
   normalizeConversionDefinitions,
   normalizeMediaConfig,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/media",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "description": "Holo-JS Framework - media collections and conversions for Holo-JS models",
   "type": "module",
   "license": "MIT",
@@ -28,14 +28,14 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/config": "^0.3.16",
-    "@holo-js/db": "^0.3.16",
-    "@holo-js/queue": "^0.3.16",
-    "@holo-js/storage": "^0.3.16",
+    "@holo-js/config": "^0.3.18",
+    "@holo-js/db": "^0.3.18",
+    "@holo-js/queue": "^0.3.18",
+    "@holo-js/storage": "^0.3.18",
     "sharp": "^0.35.4"
   },
   "devDependencies": {
-    "@holo-js/db-sqlite": "^0.3.16",
+    "@holo-js/db-sqlite": "^0.3.18",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
     "vitest": "^4.1.5"