nextly 0.0.1 → 0.0.2-alpha.0

package/dist/chunk-EGXBZCGC.mjs

@@ -0,0 +1,943 @@
+import {
+  LocalStorageAdapter
+} from "./chunk-G2AA4QLC.mjs";
+
+// src/storage/storage.ts
+var MediaStorage = class {
+  /** Registered storage plugins by name */
+  plugins = /* @__PURE__ */ new Map();
+  /** Storage adapter per collection */
+  collectionAdapters = /* @__PURE__ */ new Map();
+  /** Storage configuration per collection */
+  collectionConfigs = /* @__PURE__ */ new Map();
+  /** Local storage adapter (always available as fallback) */
+  localAdapter;
+  /**
+   * Create a new MediaStorage instance.
+   *
+   * @param config - Optional configuration for storage initialization
+   */
+  constructor(config) {
+    this.localAdapter = new LocalStorageAdapter({
+      basePath: config?.local?.uploadDir ?? "./public/uploads",
+      baseUrl: config?.local?.publicPath ?? "/uploads"
+    });
+    if (config?.plugins) {
+      for (const plugin of config.plugins) {
+        this.registerPlugin(plugin);
+      }
+    }
+  }
+  // ============================================================
+  // Plugin Registration
+  // ============================================================
+  /**
+   * Register a storage plugin.
+   *
+   * Plugins provide storage adapters for specific collections.
+   * When a collection is registered with a plugin, uploads for that
+   * collection will be routed to the plugin's adapter.
+   *
+   * @param plugin - The storage plugin to register
+   *
+   * @example
+   * ```typescript
+   * const storage = new MediaStorage();
+   *
+   * storage.registerPlugin(s3Storage({
+   *   bucket: 'my-bucket',
+   *   region: 'us-east-1',
+   *   collections: {
+   *     media: true,
+   *     'private-docs': { prefix: 'private/' }
+   *   }
+   * }));
+   * ```
+   */
+  registerPlugin(plugin) {
+    if (!plugin.adapter) {
+      return;
+    }
+    this.plugins.set(plugin.name, plugin);
+    for (const [collectionSlug, config] of Object.entries(plugin.collections)) {
+      const collectionConfig = typeof config === "boolean" ? {} : config;
+      this.collectionAdapters.set(collectionSlug, plugin.adapter);
+      this.collectionConfigs.set(collectionSlug, collectionConfig);
+    }
+  }
+  // ============================================================
+  // Adapter Resolution
+  // ============================================================
+  /**
+   * Check if any storage adapter is configured.
+   *
+   * @returns True if at least one storage plugin is registered
+   */
+  hasAdapter() {
+    return true;
+  }
+  /**
+   * Get the storage adapter if available, or null if not configured.
+   *
+   * Unlike getAdapter(), this method does not throw an error if no storage
+   * is configured. Useful for optional storage scenarios.
+   *
+   * @param collection - The collection slug (optional)
+   * @returns The storage adapter instance, or null if not configured
+   */
+  getAdapterOrNull(collection) {
+    if (collection && this.collectionAdapters.has(collection)) {
+      return this.collectionAdapters.get(collection);
+    }
+    return this.localAdapter;
+  }
+  /**
+   * Get the storage adapter for a specific collection.
+   *
+   * If a plugin is configured for the collection, returns the plugin's adapter.
+   * Otherwise, returns the default adapter (first registered plugin).
+   *
+   * @param collection - The collection slug (optional)
+   * @returns The appropriate storage adapter
+   * @throws Error if no storage plugin is configured
+   */
+  getAdapterForCollection(collection) {
+    if (collection && this.collectionAdapters.has(collection)) {
+      return this.collectionAdapters.get(collection);
+    }
+    return this.localAdapter;
+  }
+  /**
+   * Get configuration for a specific collection.
+   *
+   * @param collection - The collection slug
+   * @returns The collection's storage configuration, or undefined
+   */
+  getCollectionConfig(collection) {
+    return this.collectionConfigs.get(collection);
+  }
+  // ============================================================
+  // Core Storage Operations
+  // ============================================================
+  /**
+   * Upload file to appropriate storage based on collection.
+   *
+   * Routes the upload to the correct adapter based on collection
+   * configuration. Applies collection-specific prefix if configured.
+   *
+   * @param buffer - The file buffer to upload
+   * @param options - Upload options including filename, mimeType, collection
+   * @returns Upload result with URL and path
+   *
+   * @example
+   * ```typescript
+   * const result = await storage.upload(buffer, {
+   *   filename: 'photo.jpg',
+   *   mimeType: 'image/jpeg',
+   *   collection: 'media'
+   * });
+   * console.log(result.url); // Public URL
+   * console.log(result.path); // Storage path for deletion
+   * ```
+   */
+  async upload(buffer, options) {
+    const adapter = this.getAdapterForCollection(options.collection);
+    const config = options.collection ? this.getCollectionConfig(options.collection) : void 0;
+    const uploadOptions = { ...options };
+    if (config?.prefix) {
+      uploadOptions.folder = config.prefix + (options.folder || "");
+    }
+    return adapter.upload(buffer, uploadOptions);
+  }
+  /**
+   * Delete file from storage.
+   *
+   * Determines correct adapter based on collection.
+   *
+   * @param filePath - The storage path/key of the file
+   * @param collection - The collection slug (optional, for routing)
+   */
+  async delete(filePath, collection) {
+    const adapter = this.getAdapterForCollection(collection);
+    return adapter.delete(filePath);
+  }
+  /**
+   * Bulk delete files from storage.
+   * Uses adapter's native bulkDelete if available, otherwise falls back to
+   * sequential individual deletes in chunks of 10.
+   */
+  async bulkDelete(filePaths, collection) {
+    const adapter = this.getAdapterForCollection(collection);
+    if (adapter.bulkDelete) {
+      return adapter.bulkDelete(filePaths);
+    }
+    const successful = [];
+    const failed = [];
+    const chunkSize = 10;
+    for (let i = 0; i < filePaths.length; i += chunkSize) {
+      const chunk = filePaths.slice(i, i + chunkSize);
+      const results = await Promise.allSettled(
+        chunk.map((fp) => adapter.delete(fp))
+      );
+      results.forEach((result, idx) => {
+        const fp = chunk[idx];
+        if (result.status === "fulfilled") {
+          successful.push(fp);
+        } else {
+          failed.push({
+            filePath: fp,
+            error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+          });
+        }
+      });
+    }
+    return { successful, failed };
+  }
+  /**
+   * Check if file exists in storage.
+   *
+   * @param filePath - The storage path/key to check
+   * @param collection - The collection slug (optional, for routing)
+   * @returns True if file exists
+   */
+  async exists(filePath, collection) {
+    const adapter = this.getAdapterForCollection(collection);
+    return adapter.exists(filePath);
+  }
+  /**
+   * Get public URL for file.
+   *
+   * @param filePath - The storage path/key
+   * @param collection - The collection slug (optional, for routing)
+   * @returns Public URL to access the file
+   */
+  getPublicUrl(filePath, collection) {
+    const adapter = this.getAdapterForCollection(collection);
+    return adapter.getPublicUrl(filePath);
+  }
+  /**
+   * Get storage type for a collection.
+   *
+   * @param collection - The collection slug (optional)
+   * @returns Storage type identifier ('s3', 'vercel-blob')
+   */
+  getStorageType(collection) {
+    const adapter = this.getAdapterForCollection(collection);
+    return adapter.getType();
+  }
+  // ============================================================
+  // Client Upload Support
+  // ============================================================
+  /**
+   * Check if collection supports client-side uploads.
+   *
+   * Client-side uploads allow direct-to-storage uploads, bypassing
+   * the server. This is essential for serverless platforms with
+   * request body size limits (e.g., Vercel's 4.5MB limit).
+   *
+   * @param collection - The collection slug
+   * @returns True if client uploads are enabled and supported
+   */
+  supportsClientUploads(collection) {
+    const config = this.getCollectionConfig(collection);
+    if (!config?.clientUploads) return false;
+    const adapter = this.getAdapterForCollection(collection);
+    const info = adapter.getInfo?.();
+    return info?.supportsClientUploads ?? false;
+  }
+  /**
+   * Get client upload URL for direct-to-storage uploads.
+   *
+   * Generates a pre-signed URL that allows the client to upload
+   * directly to the storage backend, bypassing the server.
+   *
+   * Only available if:
+   * 1. Collection is configured with `clientUploads: true`
+   * 2. The storage adapter supports client uploads
+   *
+   * @param filename - Original filename
+   * @param mimeType - File MIME type
+   * @param collection - Collection slug
+   * @returns Client upload data, or null if not supported
+   *
+   * @example
+   * ```typescript
+   * // Server-side: generate upload URL
+   * const uploadData = await storage.getClientUploadUrl(
+   *   'photo.jpg',
+   *   'image/jpeg',
+   *   'media'
+   * );
+   *
+   * // Client-side: upload directly to storage
+   * await fetch(uploadData.uploadUrl, {
+   *   method: uploadData.method,
+   *   headers: uploadData.headers,
+   *   body: file
+   * });
+   * ```
+   */
+  async getClientUploadUrl(filename, mimeType, collection) {
+    if (!this.supportsClientUploads(collection)) {
+      return null;
+    }
+    for (const plugin of this.plugins.values()) {
+      if (collection in plugin.collections && plugin.getClientUploadUrl) {
+        return plugin.getClientUploadUrl(filename, mimeType, collection);
+      }
+    }
+    return null;
+  }
+  // ============================================================
+  // Signed Download Support
+  // ============================================================
+  /**
+   * Check if collection supports signed download URLs.
+   *
+   * @param collection - The collection slug
+   * @returns True if signed downloads are enabled and supported
+   */
+  supportsSignedDownloads(collection) {
+    const config = this.getCollectionConfig(collection);
+    if (!config?.signedDownloads) return false;
+    const adapter = this.getAdapterForCollection(collection);
+    const info = adapter.getInfo?.();
+    return info?.supportsSignedUrls ?? false;
+  }
+  /**
+   * Get signed download URL for secure file access.
+   *
+   * Generates a time-limited signed URL for accessing files in
+   * private storage buckets. Only works if:
+   * 1. Collection is configured with `signedDownloads: true`
+   * 2. The storage adapter supports signed URLs
+   *
+   * @param filePath - Storage path/key of the file
+   * @param collection - Collection slug
+   * @param expiresIn - URL expiry time in seconds (optional)
+   * @returns Signed URL, or null if not supported
+   *
+   * @example
+   * ```typescript
+   * const signedUrl = await storage.getSignedDownloadUrl(
+   *   'private/doc.pdf',
+   *   'private-docs',
+   *   3600 // 1 hour
+   * );
+   * ```
+   */
+  async getSignedDownloadUrl(filePath, collection, expiresIn) {
+    if (!this.supportsSignedDownloads(collection)) {
+      return null;
+    }
+    const config = this.getCollectionConfig(collection);
+    for (const plugin of this.plugins.values()) {
+      if (collection in plugin.collections && plugin.getSignedDownloadUrl) {
+        return plugin.getSignedDownloadUrl(
+          filePath,
+          expiresIn ?? config?.signedUrlExpiresIn ?? 3600
+        );
+      }
+    }
+    return null;
+  }
+  // ============================================================
+  // Accessor Methods
+  // ============================================================
+  /**
+   * Get the default storage adapter.
+   *
+   * @returns The default storage adapter (first registered plugin)
+   * @throws Error if no storage plugin is configured
+   */
+  getDefaultAdapter() {
+    return this.localAdapter;
+  }
+  /**
+   * Get list of registered plugins.
+   *
+   * @returns Array of registered storage plugins
+   */
+  getPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * Get the underlying storage adapter for a collection.
+   *
+   * Useful for passing to registerServices() which requires IStorageAdapter.
+   *
+   * @param collection - The collection slug (optional)
+   * @returns The storage adapter instance
+   */
+  getAdapter(collection) {
+    return this.getAdapterForCollection(collection);
+  }
+  /**
+   * Check if a collection has a configured storage adapter.
+   *
+   * @param collection - The collection slug
+   * @returns True if a plugin is configured for this collection
+   */
+  hasCollectionAdapter(collection) {
+    return this.collectionAdapters.has(collection);
+  }
+  /**
+   * Get list of collections with configured storage.
+   *
+   * @returns Array of collection slugs that have plugin storage
+   */
+  getConfiguredCollections() {
+    return Array.from(this.collectionAdapters.keys());
+  }
+  /**
+   * Check if any storage plugin is configured.
+   *
+   * @returns True if at least one storage plugin is registered
+   */
+  hasPlugins() {
+    return this.plugins.size > 0;
+  }
+};
+var storageInstance = null;
+function initializeMediaStorage(config) {
+  storageInstance = new MediaStorage(config);
+  return storageInstance;
+}
+function getMediaStorage() {
+  if (!storageInstance) {
+    storageInstance = new MediaStorage();
+  }
+  return storageInstance;
+}
+function resetMediaStorage() {
+  storageInstance = null;
+}
+
+// src/storage/image-processor.ts
+var sharpModule = null;
+async function getSharp() {
+  if (!sharpModule) {
+    sharpModule = (await import("sharp")).default;
+  }
+  return sharpModule;
+}
+var ImageProcessor = class {
+  /**
+   * Get image metadata without loading full image
+   */
+  async getMetadata(buffer) {
+    const sharp = await getSharp();
+    const metadata = await sharp(buffer).metadata();
+    return {
+      width: metadata.width || 0,
+      height: metadata.height || 0,
+      format: metadata.format || "unknown",
+      size: buffer.length
+    };
+  }
+  /**
+   * Generate thumbnail (300x300 by default, cropped to center)
+   *
+   * Uses "cover" fit to fill the entire 300x300 area while maintaining aspect ratio
+   */
+  async generateThumbnail(buffer, size = 300) {
+    const sharp = await getSharp();
+    const processed = await sharp(buffer).resize(size, size, {
+      fit: "cover",
+      // Crop to fill entire area
+      position: "center"
+      // Crop from center
+    }).jpeg({ quality: 80, progressive: true }).toBuffer({ resolveWithObject: true });
+    return {
+      buffer: processed.data,
+      metadata: {
+        width: processed.info.width,
+        height: processed.info.height,
+        format: processed.info.format,
+        size: processed.data.length
+      }
+    };
+  }
+  /**
+   * Optimize image (compress, convert to WebP if beneficial)
+   *
+   * Strategy:
+   * - Small images (<100KB) and already WebP: return as-is
+   * - Otherwise: convert to WebP with quality 80
+   */
+  async optimize(buffer, quality = 80) {
+    const sharp = await getSharp();
+    const metadata = await sharp(buffer).metadata();
+    if (buffer.length < 100 * 1024 && metadata.format === "webp") {
+      return {
+        buffer,
+        metadata: {
+          width: metadata.width || 0,
+          height: metadata.height || 0,
+          format: metadata.format,
+          size: buffer.length
+        }
+      };
+    }
+    const processed = await sharp(buffer).webp({ quality, effort: 4 }).toBuffer({ resolveWithObject: true });
+    return {
+      buffer: processed.data,
+      metadata: {
+        width: processed.info.width,
+        height: processed.info.height,
+        format: "webp",
+        size: processed.data.length
+      }
+    };
+  }
+  /**
+   * Resize image to specific dimensions
+   *
+   * @param maxWidth Maximum width (maintains aspect ratio)
+   * @param maxHeight Maximum height (maintains aspect ratio)
+   */
+  async resize(buffer, maxWidth, maxHeight) {
+    const sharp = await getSharp();
+    const processed = await sharp(buffer).resize(maxWidth, maxHeight, {
+      fit: "inside",
+      // Fit within bounds, maintaining aspect ratio
+      withoutEnlargement: true
+      // Don't upscale small images
+    }).toBuffer({ resolveWithObject: true });
+    return {
+      buffer: processed.data,
+      metadata: {
+        width: processed.info.width,
+        height: processed.info.height,
+        format: processed.info.format,
+        size: processed.data.length
+      }
+    };
+  }
+  /**
+   * Resize an image with focal point awareness and format conversion.
+   *
+   * When fit is 'cover' and a focal point is set, the crop anchors at that
+   * point instead of center. Supports format conversion ('auto' outputs webp
+   * for jpeg/png/tiff sources, keeps original for gif).
+   */
+  async resizeWithFocalPoint(buffer, options) {
+    const sharp = await getSharp();
+    const quality = options.quality ?? 80;
+    const metadata = await sharp(buffer).metadata();
+    const originalFormat = metadata.format || "jpeg";
+    let outputFormat = originalFormat;
+    if (options.format && options.format !== "auto") {
+      outputFormat = options.format;
+    } else if (options.format === "auto") {
+      const convertibleFormats = ["jpeg", "png", "tiff", "jpg"];
+      if (convertibleFormats.includes(originalFormat)) {
+        outputFormat = "webp";
+      }
+    }
+    let pipeline = sharp(buffer);
+    const hasFocalPoint = options.fit === "cover" && (options.focalX !== void 0 || options.focalY !== void 0) && options.width && options.height && metadata.width && metadata.height;
+    if (hasFocalPoint) {
+      const srcW = metadata.width;
+      const srcH = metadata.height;
+      const tgtW = options.width;
+      const tgtH = options.height;
+      const fx = (options.focalX ?? 50) / 100;
+      const fy = (options.focalY ?? 50) / 100;
+      const tgtAspect = tgtW / tgtH;
+      let cropW;
+      let cropH;
+      if (srcW / srcH > tgtAspect) {
+        cropH = srcH;
+        cropW = Math.round(srcH * tgtAspect);
+      } else {
+        cropW = srcW;
+        cropH = Math.round(srcW / tgtAspect);
+      }
+      let left = Math.round(fx * srcW - cropW / 2);
+      let top = Math.round(fy * srcH - cropH / 2);
+      left = Math.max(0, Math.min(srcW - cropW, left));
+      top = Math.max(0, Math.min(srcH - cropH, top));
+      pipeline = pipeline.extract({ left, top, width: cropW, height: cropH }).resize(tgtW, tgtH, { fit: "fill" });
+    } else {
+      pipeline = pipeline.resize(
+        options.width || void 0,
+        options.height || void 0,
+        {
+          fit: options.fit,
+          position: "center",
+          withoutEnlargement: true
+        }
+      );
+    }
+    switch (outputFormat) {
+      case "webp":
+        pipeline = pipeline.webp({ quality, effort: 4 });
+        break;
+      case "jpeg":
+      case "jpg":
+        pipeline = pipeline.jpeg({ quality, progressive: true });
+        outputFormat = "jpeg";
+        break;
+      case "png":
+        pipeline = pipeline.png({ quality });
+        break;
+      case "avif":
+        pipeline = pipeline.avif({ quality });
+        break;
+      default:
+        break;
+    }
+    const result = await pipeline.toBuffer({ resolveWithObject: true });
+    return {
+      buffer: result.data,
+      width: result.info.width,
+      height: result.info.height,
+      format: outputFormat,
+      size: result.data.length
+    };
+  }
+  /**
+   * Check if buffer is a valid image
+   */
+  async isValidImage(buffer) {
+    try {
+      const sharp = await getSharp();
+      await sharp(buffer).metadata();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get image dimensions quickly (without full processing)
+   */
+  async getDimensions(buffer) {
+    try {
+      const sharp = await getSharp();
+      const metadata = await sharp(buffer).metadata();
+      if (metadata.width && metadata.height) {
+        return { width: metadata.width, height: metadata.height };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+var processorInstance = null;
+function getImageProcessor() {
+  if (!processorInstance) {
+    processorInstance = new ImageProcessor();
+  }
+  return processorInstance;
+}
+function resetImageProcessor() {
+  processorInstance = null;
+}
+
+// src/storage/image-sizes.ts
+function getExtensionForFormat(format) {
+  switch (format) {
+    case "jpeg":
+    case "jpg":
+      return "jpg";
+    case "webp":
+      return "webp";
+    case "png":
+      return "png";
+    case "avif":
+      return "avif";
+    default:
+      return format;
+  }
+}
+function getMimeTypeForFormat(format) {
+  switch (format) {
+    case "jpeg":
+    case "jpg":
+      return "image/jpeg";
+    case "webp":
+      return "image/webp";
+    case "png":
+      return "image/png";
+    case "avif":
+      return "image/avif";
+    default:
+      return `image/${format}`;
+  }
+}
+function buildVariantFilename(originalFilename, sizeName, format) {
+  const lastDot = originalFilename.lastIndexOf(".");
+  const baseName = lastDot > 0 ? originalFilename.substring(0, lastDot) : originalFilename;
+  const ext = getExtensionForFormat(format);
+  return `${baseName}-${sizeName}.${ext}`;
+}
+async function generateImageSizes(originalBuffer, originalFilename, sizes, uploadFn, options = {}) {
+  if (sizes.length === 0) return {};
+  const processor = getImageProcessor();
+  const results = {};
+  for (const sizeConfig of sizes) {
+    try {
+      if (!sizeConfig.width && !sizeConfig.height) continue;
+      const resized = await processor.resizeWithFocalPoint(originalBuffer, {
+        width: sizeConfig.width ?? void 0,
+        height: sizeConfig.height ?? void 0,
+        fit: sizeConfig.fit,
+        quality: sizeConfig.quality,
+        format: sizeConfig.format,
+        focalX: options.focalX ?? void 0,
+        focalY: options.focalY ?? void 0
+      });
+      const variantFilename = buildVariantFilename(
+        originalFilename,
+        sizeConfig.name,
+        resized.format
+      );
+      const mimeType = getMimeTypeForFormat(resized.format);
+      const uploadResult = await uploadFn(resized.buffer, {
+        filename: variantFilename,
+        mimeType,
+        folder: options.folder,
+        collection: options.collection
+      });
+      results[sizeConfig.name] = {
+        url: uploadResult.url,
+        path: uploadResult.path,
+        width: resized.width,
+        height: resized.height,
+        filesize: resized.size,
+        mimeType,
+        filename: variantFilename
+      };
+    } catch (error) {
+      console.warn(
+        `[ImageSizes] Failed to generate size "${sizeConfig.name}":`,
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+  return results;
+}
+async function deleteImageSizes(sizes, deleteFn) {
+  if (!sizes) return;
+  const paths = Object.values(sizes).map((v) => v.path).filter(Boolean);
+  await Promise.allSettled(paths.map((path) => deleteFn(path)));
+}
+
+// src/storage/retry.ts
+var DEFAULT_OPTIONS = {
+  maxAttempts: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  backoffFactor: 2,
+  jitter: true
+};
+function isTransientError(error) {
+  if (!error) return false;
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    const name = error.name.toLowerCase();
+    if (message.includes("timeout") || message.includes("timed out") || message.includes("etimedout") || message.includes("econnreset") || message.includes("econnrefused") || message.includes("enotfound") || message.includes("enetunreach") || message.includes("socket hang up") || message.includes("network") || name.includes("timeout") || name.includes("abort")) {
+      return true;
+    }
+    if (message.includes("rate limit") || message.includes("too many")) {
+      return true;
+    }
+  }
+  const errorAny = error;
+  const metadata = errorAny.$metadata;
+  if (errorAny.statusCode || errorAny.status || metadata?.httpStatusCode) {
+    const status = errorAny.statusCode || errorAny.status || metadata?.httpStatusCode;
+    const statusNum = typeof status === "number" ? status : Number(status);
+    if (statusNum === 429 || statusNum >= 500 && statusNum < 600) {
+      return true;
+    }
+  }
+  if (errorAny.code) {
+    const code = String(errorAny.code).toLowerCase();
+    if (code.includes("timeout") || code.includes("throttl") || code.includes("serviceunavailable") || code.includes("slowdown") || code === "econnreset" || code === "epipe") {
+      return true;
+    }
+  }
+  return false;
+}
+function calculateDelay(attempt, options) {
+  const { baseDelayMs, maxDelayMs, backoffFactor, jitter } = options;
+  const exponentialDelay = baseDelayMs * Math.pow(backoffFactor, attempt - 1);
+  const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+  if (jitter) {
+    const jitterAmount = cappedDelay * Math.random() * 0.5;
+    return Math.floor(cappedDelay + jitterAmount);
+  }
+  return Math.floor(cappedDelay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, options = {}) {
+  const config = { ...DEFAULT_OPTIONS, ...options };
+  const { maxAttempts, shouldRetry, onRetry } = {
+    ...config,
+    shouldRetry: options.shouldRetry ?? isTransientError,
+    onRetry: options.onRetry
+  };
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const isLastAttempt = attempt >= maxAttempts;
+      const canRetry = !isLastAttempt && shouldRetry(error, attempt);
+      if (!canRetry) {
+        throw error;
+      }
+      const delayMs = calculateDelay(attempt, config);
+      if (onRetry) {
+        onRetry(error, attempt, delayMs);
+      }
+      await sleep(delayMs);
+    }
+  }
+  throw lastError;
+}
+function createRetryable(fn, options = {}) {
+  return (...args) => withRetry(() => fn(...args), options);
+}
+
+// src/storage/svg-security.ts
+var SVG_CSP_HEADER = "script-src 'none'; style-src 'unsafe-inline'";
+function isSvgMimeType(mimeType) {
+  return mimeType.toLowerCase().trim() === "image/svg+xml";
+}
+function getSvgSecurityHeaders() {
+  return {
+    "Content-Security-Policy": SVG_CSP_HEADER,
+    "X-Content-Type-Options": "nosniff"
+  };
+}
+
+// src/storage/env-config.ts
+async function ensureEnvLoaded() {
+  if (typeof process !== "undefined" && !process.env._NEXTLY_ENV_LOADED) {
+    try {
+      const dotenv = await import("dotenv");
+      dotenv.config();
+      process.env._NEXTLY_ENV_LOADED = "true";
+    } catch {
+    }
+  }
+}
+async function getStorageFromEnv() {
+  await ensureEnvLoaded();
+  const blobToken = process.env.BLOB_READ_WRITE_TOKEN;
+  if (blobToken) {
+    try {
+      const pkg = "@nextlyhq/storage-vercel-blob";
+      const { vercelBlobStorage } = await import(
+        /* webpackIgnore: true */
+        pkg
+      );
+      console.log(
+        "[Nextly] Storage: Vercel Blob (auto-detected from BLOB_READ_WRITE_TOKEN)"
+      );
+      return [
+        vercelBlobStorage({ token: blobToken, collections: { media: true } })
+      ];
+    } catch {
+      console.warn(
+        "[Nextly] BLOB_READ_WRITE_TOKEN set but @nextlyhq/storage-vercel-blob not installed. Run: pnpm add @nextlyhq/storage-vercel-blob"
+      );
+    }
+  }
+  const s3Bucket = process.env.S3_BUCKET;
+  if (s3Bucket) {
+    const region = process.env.S3_REGION;
+    const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
+    const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+    if (!region || !accessKeyId || !secretAccessKey) {
+      const missing = [];
+      if (!region) missing.push("S3_REGION");
+      if (!accessKeyId) missing.push("AWS_ACCESS_KEY_ID");
+      if (!secretAccessKey) missing.push("AWS_SECRET_ACCESS_KEY");
+      console.warn(
+        `[Nextly] S3_BUCKET set but missing: ${missing.join(", ")}. Falling back to local storage.`
+      );
+    } else {
+      try {
+        const pkg = "@nextlyhq/storage-s3";
+        const { s3Storage } = await import(
+          /* webpackIgnore: true */
+          pkg
+        );
+        console.log("[Nextly] Storage: S3 (auto-detected from S3_BUCKET)");
+        return [
+          s3Storage({
+            bucket: s3Bucket,
+            region,
+            accessKeyId,
+            secretAccessKey,
+            endpoint: process.env.S3_ENDPOINT,
+            // eslint-disable-next-line turbo/no-undeclared-env-vars
+            publicUrl: process.env.S3_PUBLIC_URL,
+            // eslint-disable-next-line turbo/no-undeclared-env-vars
+            forcePathStyle: process.env.S3_FORCE_PATH_STYLE === "true",
+            collections: { media: true }
+          })
+        ];
+      } catch {
+        console.warn(
+          "[Nextly] S3_BUCKET set but @nextlyhq/storage-s3 not installed. Run: pnpm add @nextlyhq/storage-s3"
+        );
+      }
+    }
+  }
+  const uploadthingToken = process.env.UPLOADTHING_TOKEN;
+  if (uploadthingToken) {
+    try {
+      const pkg = "@nextlyhq/storage-uploadthing";
+      const { uploadthingStorage } = await import(
+        /* webpackIgnore: true */
+        pkg
+      );
+      console.log(
+        "[Nextly] Storage: Uploadthing (auto-detected from UPLOADTHING_TOKEN)"
+      );
+      return [
+        uploadthingStorage({
+          token: uploadthingToken,
+          collections: { media: true }
+        })
+      ];
+    } catch {
+      console.warn(
+        "[Nextly] UPLOADTHING_TOKEN set but @nextlyhq/storage-uploadthing not installed. Run: pnpm add @nextlyhq/storage-uploadthing"
+      );
+    }
+  }
+  const { localStorage: localStorage2 } = await import("./local-plugin-PTET4NAT.mjs");
+  console.log(
+    "[Nextly] Storage: Local disk (no cloud env vars detected, using ./public/uploads)"
+  );
+  return [localStorage2({ collections: { media: true } })];
+}
+
+export {
+  MediaStorage,
+  initializeMediaStorage,
+  getMediaStorage,
+  resetMediaStorage,
+  ImageProcessor,
+  getImageProcessor,
+  resetImageProcessor,
+  generateImageSizes,
+  deleteImageSizes,
+  isTransientError,
+  withRetry,
+  createRetryable,
+  SVG_CSP_HEADER,
+  isSvgMimeType,
+  getSvgSecurityHeaders,
+  getStorageFromEnv
+};