@od-oneapp/storage 2026.1.1301

package/dist/health-check-D7LnnDec.mjs

@@ -0,0 +1,746 @@
+import { t as VercelBlobProvider } from "./vercel-blob-DA8HaYuw.mjs";
+import { createRequire } from "node:module";
+import { logWarn } from "@od-oneapp/shared/logs";
+
+//#region providers/cloudflare-images.ts
+/**
+* @fileoverview Cloudflare Images storage provider
+*
+* Lazy shim around the monorepo integration package.
+*
+* Why:
+* - `@integrations/*` packages are monorepo-private and may not be installed in extracted apps.
+* - This avoids hard module resolution failures during bundling/build; the integration is only
+*   required if the provider is instantiated.
+*/
+const require$1 = createRequire(import.meta.url);
+function loadProvider$1() {
+	return require$1("@integrations/cloudflare/storage-provider/images").CloudflareImagesProvider;
+}
+const CloudflareImagesProvider = class CloudflareImagesProviderShim {
+	constructor(...args) {
+		return new (loadProvider$1())(...args);
+	}
+};
+
+//#endregion
+//#region providers/cloudflare-r2.ts
+/**
+* @fileoverview Cloudflare R2 storage provider
+*
+* Lazy shim around the monorepo integration package.
+*
+* Why:
+* - `@integrations/*` packages are monorepo-private and may not be installed in extracted apps.
+* - This avoids hard module resolution failures during bundling/build; the integration is only
+*   required if the provider is instantiated.
+*/
+const require = createRequire(import.meta.url);
+function loadProvider() {
+	return require("@integrations/cloudflare/storage-provider/r2").CloudflareR2Provider;
+}
+const CloudflareR2Provider = class CloudflareR2ProviderShim {
+	constructor(...args) {
+		return new (loadProvider())(...args);
+	}
+};
+
+//#endregion
+//#region src/constants.ts
+/**
+* @fileoverview Storage Package Constants
+*
+* Centralized constants for storage operations to avoid magic numbers
+* and improve maintainability.
+*
+* Includes:
+* - URL expiration times
+* - File size limits
+* - Multipart upload thresholds
+* - Retry configuration
+* - Rate limiting settings
+*
+* @module @od-oneapp/storage/constants
+*/
+const STORAGE_CONSTANTS = {
+	DEFAULT_URL_EXPIRY_SECONDS: 3600,
+	PRODUCT_URL_EXPIRY_SECONDS: 3600,
+	UPLOAD_URL_EXPIRY_SECONDS: 1800,
+	ADMIN_URL_EXPIRY_SECONDS: 7200,
+	MULTIPART_THRESHOLD_BYTES: 100 * 1024 * 1024,
+	DEFAULT_PART_SIZE_BYTES: 5 * 1024 * 1024,
+	DEFAULT_MAX_PART_SIZE_BYTES: 25 * 1024 * 1024,
+	DEFAULT_QUEUE_SIZE: 4,
+	DEFAULT_BATCH_SIZE: 5,
+	MAX_BATCH_SIZE: 50,
+	DEFAULT_REQUEST_TIMEOUT_MS: 3e4,
+	DEFAULT_UPLOAD_TIMEOUT_MS: 3e5,
+	DEFAULT_DOWNLOAD_TIMEOUT_MS: 6e4,
+	DEFAULT_MAX_RETRIES: 3,
+	RETRY_BASE_DELAY_MS: 1e3,
+	MAX_KEY_LENGTH: 1024,
+	MAX_FILENAME_LENGTH: 255,
+	DEFAULT_RATE_LIMIT_REQUESTS: 100,
+	DEFAULT_RATE_LIMIT_WINDOW_MS: 60 * 1e3,
+	HEALTH_CHECK_KEY: "__health_check__"
+};
+/**
+* File size thresholds for multipart upload decisions
+*/
+const MULTIPART_THRESHOLDS = {
+	SMALL_FILE: 100 * 1024 * 1024,
+	MEDIUM_FILE: 1024 * 1024 * 1024,
+	LARGE_FILE: Infinity
+};
+/**
+* Part sizes based on file size
+*/
+const PART_SIZES = {
+	SMALL: 5 * 1024 * 1024,
+	MEDIUM: 10 * 1024 * 1024,
+	LARGE: 25 * 1024 * 1024
+};
+/**
+* Default storage capabilities for providers that don't implement getCapabilities()
+* Single source of truth for capability defaults
+*/
+const DEFAULT_STORAGE_CAPABILITIES = {
+	multipart: false,
+	presignedUrls: false,
+	progressTracking: false,
+	abortSignal: false,
+	metadata: false,
+	customDomains: false,
+	edgeCompatible: false,
+	versioning: false,
+	encryption: false,
+	directoryListing: false
+};
+
+//#endregion
+//#region src/multi-storage.ts
+/**
+* @fileoverview Multi-storage provider manager
+*
+* Manages multiple storage providers with routing and fallback capabilities.
+* Allows using different providers for different use cases or as backups.
+*
+* Features:
+* - Provider routing based on key patterns
+* - Fallback to default provider
+* - Unified API across multiple providers
+*
+* @module @od-oneapp/storage/multi-storage
+*/
+var MultiStorageManager = class {
+	providers = /* @__PURE__ */ new Map();
+	defaultProvider;
+	routing;
+	constructor(config) {
+		for (const [name, providerConfig] of Object.entries(config.providers)) this.providers.set(name, this.createProvider(providerConfig));
+		const firstProvider = Object.keys(config.providers)[0];
+		this.defaultProvider = config.defaultProvider ?? firstProvider ?? "";
+		if (!this.defaultProvider) throw new Error("No storage providers configured");
+		this.routing = config.routing;
+	}
+	createProvider(config) {
+		switch (config.provider) {
+			case "multi": throw new Error("Multi provider cannot be nested");
+			case "cloudflare-r2":
+				if (!config.cloudflareR2) throw new Error("Cloudflare R2 configuration is required");
+				if (Array.isArray(config.cloudflareR2)) {
+					if (config.cloudflareR2.length === 0) throw new Error("No R2 configurations provided");
+					const firstR2Config = config.cloudflareR2[0];
+					if (!firstR2Config) throw new Error("First R2 configuration is undefined");
+					return new CloudflareR2Provider(firstR2Config);
+				}
+				return new CloudflareR2Provider(config.cloudflareR2);
+			case "cloudflare-images":
+				if (!config.cloudflareImages) throw new Error("Cloudflare Images configuration is required");
+				return new CloudflareImagesProvider(config.cloudflareImages);
+			case "vercel-blob":
+				if (!config.vercelBlob?.token) throw new Error("Vercel Blob token is required");
+				return new VercelBlobProvider(config.vercelBlob.token);
+			default: throw new Error(`Unknown storage provider: ${config.provider}`);
+		}
+	}
+	getProviderForKey(key) {
+		if (this.routing) {
+			const extension = key.split(".").pop()?.toLowerCase();
+			if (this.routing.images && this.isImageFile(extension)) {
+				const provider = this.providers.get(this.routing.images);
+				if (provider) return {
+					provider,
+					providerName: this.routing.images
+				};
+			}
+			if (this.routing.documents && this.isDocumentFile(extension)) {
+				const provider = this.providers.get(this.routing.documents);
+				if (provider) return {
+					provider,
+					providerName: this.routing.documents
+				};
+			}
+			for (const [pattern, providerName] of Object.entries(this.routing)) if (pattern !== "images" && pattern !== "documents" && providerName) {
+				if (key.includes(pattern)) {
+					const provider = this.providers.get(providerName);
+					if (provider) return {
+						provider,
+						providerName
+					};
+				}
+			}
+		}
+		const provider = this.providers.get(this.defaultProvider);
+		if (!provider) throw new Error(`Default provider '${this.defaultProvider}' not found`);
+		return {
+			provider,
+			providerName: this.defaultProvider
+		};
+	}
+	isImageFile(extension) {
+		return extension ? [
+			"jpg",
+			"jpeg",
+			"png",
+			"gif",
+			"webp",
+			"avif",
+			"svg",
+			"ico"
+		].includes(extension) : false;
+	}
+	isDocumentFile(extension) {
+		return extension ? [
+			"pdf",
+			"doc",
+			"docx",
+			"xls",
+			"xlsx",
+			"ppt",
+			"pptx",
+			"txt",
+			"csv"
+		].includes(extension) : false;
+	}
+	getProvider(name) {
+		return this.providers.get(name);
+	}
+	async delete(key) {
+		const { provider } = this.getProviderForKey(key);
+		return provider.delete(key);
+	}
+	async download(key) {
+		const { provider } = this.getProviderForKey(key);
+		return provider.download(key);
+	}
+	async exists(key) {
+		const { provider } = this.getProviderForKey(key);
+		return provider.exists(key);
+	}
+	async getMetadata(key) {
+		const { provider } = this.getProviderForKey(key);
+		return provider.getMetadata(key);
+	}
+	async getUrl(key, options) {
+		const { provider } = this.getProviderForKey(key);
+		return provider.getUrl(key, options);
+	}
+	async list(options) {
+		if (options?.provider) {
+			const provider = this.providers.get(options.provider);
+			if (!provider) throw new Error(`Provider '${options.provider}' not found`);
+			return provider.list(options);
+		}
+		const allResults = [];
+		for (const provider of this.providers.values()) {
+			const results = await provider.list(options);
+			allResults.push(...results);
+		}
+		return allResults;
+	}
+	async upload(key, data, options) {
+		let provider;
+		if (options?.provider) {
+			const requestedProvider = this.providers.get(options.provider);
+			if (!requestedProvider) throw new Error(`Provider '${options.provider}' not found`);
+			provider = requestedProvider;
+		} else {
+			const { provider: routedProvider } = this.getProviderForKey(key);
+			provider = routedProvider;
+		}
+		return provider.upload(key, data, options);
+	}
+	async getCloudflareImagesProvider() {
+		for (const provider of this.providers.values()) if (provider instanceof CloudflareImagesProvider) return provider;
+	}
+	getProviderNames() {
+		return Array.from(this.providers.keys());
+	}
+};
+
+//#endregion
+//#region src/multipart.ts
+/**
+* @fileoverview Unified Multipart Upload Manager
+*
+* Provides a consistent interface for multipart uploads across all storage providers.
+* Handles provider-specific differences and provides retry logic, progress tracking,
+* and error recovery.
+*
+* Features:
+* - Automatic part size calculation
+* - Concurrent part uploads
+* - Progress tracking
+* - Resume support
+* - Error recovery
+*
+* @module @od-oneapp/storage/multipart
+*/
+var MultipartUploadManager = class {
+	provider;
+	state = null;
+	abortController = null;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	/**
+	* Check if provider supports multipart uploads
+	*/
+	supportsMultipart() {
+		return (this.provider.getCapabilities?.())?.multipart ?? false;
+	}
+	/**
+	* Create a new multipart upload
+	*
+	* @param key - Storage key
+	* @param totalSize - Total file size in bytes
+	* @param options - Upload options
+	* @returns Upload state
+	*/
+	async createUpload(key, totalSize, options = {}) {
+		if (!this.supportsMultipart()) throw new Error("Provider does not support multipart uploads");
+		if (this.state && !this.state.completed && !this.state.aborted) throw new Error("Upload already in progress. Abort current upload first.");
+		const partSize = this.calculatePartSize(totalSize, options.partSize);
+		const totalParts = Math.ceil(totalSize / partSize);
+		const uploadOptions = { onProgress: options.onProgress ? (progress) => {
+			options.onProgress?.({
+				key: progress.key,
+				loaded: progress.loaded,
+				total: progress.total,
+				part: progress.part ?? 0,
+				percentage: progress.percentage ?? 0
+			});
+		} : void 0 };
+		const result = await this.provider.createMultipartUpload?.(key, uploadOptions);
+		if (!result) throw new Error("Failed to create multipart upload");
+		this.state = {
+			uploadId: result.uploadId,
+			key: result.key,
+			provider: this.getProviderName(),
+			parts: Array.from({ length: totalParts }, (_, i) => ({
+				partNumber: i + 1,
+				size: i === totalParts - 1 ? totalSize - i * partSize : partSize,
+				uploaded: false
+			})),
+			totalSize,
+			uploadedSize: 0,
+			completed: false,
+			aborted: false
+		};
+		this.abortController = new AbortController();
+		return this.state;
+	}
+	/**
+	* Upload a part
+	*
+	* @param partNumber - Part number (1-based)
+	* @param data - Part data
+	* @param options - Upload options
+	* @returns Upload result
+	*/
+	async uploadPart(partNumber, data, options = {}) {
+		if (!this.state) throw new Error("No active upload. Call createUpload first.");
+		if (this.state.completed || this.state.aborted) throw new Error("Upload is completed or aborted");
+		const part = this.state.parts.find((p) => p.partNumber === partNumber);
+		if (!part) throw new Error(`Part ${partNumber} not found`);
+		if (part.uploaded) throw new Error(`Part ${partNumber} already uploaded`);
+		if (this.abortController?.signal.aborted) throw new Error("Upload aborted");
+		try {
+			const result = await this.uploadPartWithRetry(partNumber, data, options);
+			part.etag = result.etag;
+			part.uploaded = true;
+			this.state.uploadedSize += part.size;
+			if (options.onProgress) options.onProgress({
+				key: this.state.key,
+				loaded: this.state.uploadedSize,
+				total: this.state.totalSize,
+				part: partNumber,
+				percentage: this.state.uploadedSize / this.state.totalSize * 100
+			});
+			return result;
+		} catch (error) {
+			this.state.error = error instanceof Error ? error.message : String(error);
+			throw error;
+		}
+	}
+	/**
+	* Complete the multipart upload
+	*
+	* @returns Final upload result
+	*/
+	async completeUpload() {
+		if (!this.state) throw new Error("No active upload. Call createUpload first.");
+		if (this.state.completed) throw new Error("Upload already completed");
+		if (this.state.aborted) throw new Error("Upload was aborted");
+		const unuploadedParts = this.state.parts.filter((p) => !p.uploaded);
+		if (unuploadedParts.length > 0) throw new Error(`Upload incomplete: ${unuploadedParts.length} parts not uploaded`);
+		try {
+			const parts = this.state.parts.filter((p) => p.etag).map((p) => ({
+				partNumber: p.partNumber,
+				etag: p.etag ?? ""
+			})).filter((p) => p.etag !== "");
+			const result = await this.provider.completeMultipartUpload?.(this.state.uploadId, parts);
+			if (!result) throw new Error("Failed to complete multipart upload");
+			this.state.completed = true;
+			return {
+				...result,
+				key: result.key ?? this.state.key,
+				uploadId: this.state.uploadId,
+				parts: this.state.parts.filter((p) => p.etag).map((p) => ({
+					partNumber: p.partNumber,
+					etag: p.etag ?? "",
+					size: p.size
+				})),
+				totalParts: this.state.parts.length
+			};
+		} catch (error) {
+			this.state.error = error instanceof Error ? error.message : String(error);
+			throw error;
+		}
+	}
+	/**
+	* Abort the multipart upload
+	*/
+	async abortUpload() {
+		if (!this.state) return;
+		if (this.state.completed) return;
+		this.abortController?.abort();
+		this.state.aborted = true;
+		try {
+			await this.provider.abortMultipartUpload?.(this.state.uploadId);
+		} catch (error) {
+			logWarn("Failed to abort upload on provider", {
+				error: error instanceof Error ? error.message : String(error),
+				uploadId: this.state.uploadId,
+				key: this.state.key
+			});
+		}
+		this.state = null;
+		this.abortController = null;
+	}
+	/**
+	* Get current upload state
+	*/
+	getState() {
+		return this.state;
+	}
+	/**
+	* Resume upload from state (for recovery)
+	*
+	* @param state - Previous upload state
+	*/
+	async resumeUpload(state) {
+		if (this.state && !this.state.completed && !this.state.aborted) throw new Error("Upload already in progress");
+		this.state = { ...state };
+		this.abortController = new AbortController();
+	}
+	/**
+	* Upload file in chunks automatically
+	*
+	* @param key - Storage key
+	* @param data - File data
+	* @param options - Upload options
+	* @returns Upload result
+	*/
+	async uploadFile(key, data, options = {}) {
+		const totalSize = data instanceof ArrayBuffer ? data.byteLength : data instanceof Buffer ? data.length : data.size;
+		await this.createUpload(key, totalSize, options);
+		const partSize = this.calculatePartSize(totalSize, options.partSize);
+		const totalParts = Math.ceil(totalSize / partSize);
+		for (let i = 0; i < totalParts; i++) {
+			const start = i * partSize;
+			const end = Math.min(start + partSize, totalSize);
+			const partData = data.slice(start, end);
+			await this.uploadPart(i + 1, partData, { onProgress: options.onProgress ? (progress) => {
+				options.onProgress?.({
+					key: progress.key,
+					loaded: progress.loaded,
+					total: progress.total,
+					part: progress.part ?? 0,
+					percentage: progress.percentage ?? 0
+				});
+			} : void 0 });
+		}
+		return await this.completeUpload();
+	}
+	async uploadPartWithRetry(partNumber, data, options, maxRetries = 3) {
+		let lastError = null;
+		for (let attempt = 1; attempt <= maxRetries; attempt++) try {
+			if (!this.state?.uploadId) throw new Error("Upload ID not initialized");
+			const result = await this.provider.uploadPart?.(this.state.uploadId, partNumber, data, {
+				...options,
+				abortSignal: this.abortController?.signal
+			});
+			if (!result) throw new Error("Failed to upload part");
+			return {
+				etag: result.etag ?? "",
+				partNumber: result.partNumber ?? partNumber,
+				size: data instanceof ArrayBuffer ? data.byteLength : data instanceof Buffer ? data.length : data.size
+			};
+		} catch (error) {
+			lastError = error instanceof Error ? error : new Error(String(error));
+			if (this.abortController?.signal.aborted) throw lastError;
+			if (lastError.message.includes("validation") || lastError.message.includes("invalid")) throw lastError;
+			if (attempt < maxRetries) await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * STORAGE_CONSTANTS.RETRY_BASE_DELAY_MS));
+		}
+		throw lastError ?? /* @__PURE__ */ new Error("Upload failed after retries");
+	}
+	calculatePartSize(totalSize, userPartSize) {
+		if (userPartSize) return Math.min(userPartSize, totalSize);
+		if (totalSize < MULTIPART_THRESHOLDS.SMALL_FILE) return PART_SIZES.SMALL;
+		else if (totalSize < MULTIPART_THRESHOLDS.MEDIUM_FILE) return PART_SIZES.MEDIUM;
+		else {
+			const minPartSize = Math.ceil(totalSize / 9999);
+			return Math.max(PART_SIZES.LARGE, minPartSize);
+		}
+	}
+	getProviderName() {
+		return this.provider.constructor.name;
+	}
+};
+/**
+* Create a multipart upload manager for a provider
+*
+* @param provider - Storage provider
+* @returns Multipart upload manager
+*/
+function createMultipartUploadManager(provider) {
+	if (!hasMultipartSupport(provider)) throw new Error("The provided storage provider does not support multipart uploads");
+	return new MultipartUploadManager(provider);
+}
+/**
+* Determines whether the given storage provider supports multipart uploads.
+*
+* @param provider - The storage provider to check
+* @returns `true` if the provider supports multipart uploads, `false` otherwise.
+*/
+function hasMultipartSupport(provider) {
+	return (provider.getCapabilities?.())?.multipart ?? false;
+}
+/**
+* Selects an appropriate multipart upload part size for a file.
+*
+* If `userPartSize` is provided, it will be capped at the file size; otherwise the part size
+* is chosen from configured thresholds for small, medium, or large files.
+*
+* @param fileSize - File size in bytes
+* @param userPartSize - Optional user-specified part size in bytes; capped to `fileSize` when provided
+* @returns The selected part size in bytes
+*/
+function getOptimalPartSize(fileSize, userPartSize) {
+	if (userPartSize) return Math.min(userPartSize, fileSize);
+	if (fileSize < MULTIPART_THRESHOLDS.SMALL_FILE) return PART_SIZES.SMALL;
+	else if (fileSize < MULTIPART_THRESHOLDS.MEDIUM_FILE) return PART_SIZES.MEDIUM;
+	else {
+		const minPartSize = Math.ceil(fileSize / 9999);
+		return Math.max(PART_SIZES.LARGE, minPartSize);
+	}
+}
+
+//#endregion
+//#region src/capabilities.ts
+/**
+* @fileoverview Storage Provider Capabilities Utilities
+*
+* Provides utilities for checking storage provider capabilities and feature support.
+* Helps determine which features are available for each provider.
+*
+* @module @od-oneapp/storage/capabilities
+*/
+/**
+* Check if a storage provider has a specific capability
+* @param provider - The storage provider to check
+* @param capability - The capability to check for
+* @returns True if the provider supports the capability
+*/
+function hasCapability(provider, capability) {
+	return (provider.getCapabilities?.())?.[capability] ?? false;
+}
+/**
+* Check if a storage provider supports multiple capabilities
+* @param provider - The storage provider to check
+* @param capabilities - Array of capabilities to check for
+* @returns True if the provider supports all capabilities
+*/
+function hasAllCapabilities(provider, capabilities) {
+	return capabilities.every((capability) => hasCapability(provider, capability));
+}
+/**
+* Check if a storage provider supports any of the specified capabilities
+* @param provider - The storage provider to check
+* @param capabilities - Array of capabilities to check for
+* @returns True if the provider supports at least one capability
+*/
+function hasAnyCapability(provider, capabilities) {
+	return capabilities.some((capability) => hasCapability(provider, capability));
+}
+/**
+* Get all capabilities supported by a storage provider
+* @param provider - The storage provider to check
+* @returns Object with all capabilities and their support status
+*/
+function getProviderCapabilities(provider) {
+	return provider.getCapabilities?.() ?? { ...DEFAULT_STORAGE_CAPABILITIES };
+}
+/**
+* Get a human-readable description of provider capabilities
+* @param provider - The storage provider to describe
+* @returns String describing the provider's capabilities
+*/
+function describeProviderCapabilities(provider) {
+	const capabilities = getProviderCapabilities(provider);
+	const supportedFeatures = [];
+	const unsupportedFeatures = [];
+	if (capabilities.multipart) supportedFeatures.push("multipart uploads");
+	else unsupportedFeatures.push("multipart uploads");
+	if (capabilities.presignedUrls) supportedFeatures.push("presigned URLs");
+	else unsupportedFeatures.push("presigned URLs");
+	if (capabilities.progressTracking) supportedFeatures.push("progress tracking");
+	else unsupportedFeatures.push("progress tracking");
+	if (capabilities.abortSignal) supportedFeatures.push("abort signals");
+	else unsupportedFeatures.push("abort signals");
+	if (capabilities.metadata) supportedFeatures.push("metadata");
+	else unsupportedFeatures.push("metadata");
+	if (capabilities.customDomains) supportedFeatures.push("custom domains");
+	else unsupportedFeatures.push("custom domains");
+	if (capabilities.edgeCompatible) supportedFeatures.push("edge runtime");
+	else unsupportedFeatures.push("edge runtime");
+	let description = `Provider supports: ${supportedFeatures.join(", ")}`;
+	if (unsupportedFeatures.length > 0) description += `\nProvider does not support: ${unsupportedFeatures.join(", ")}`;
+	return description;
+}
+/**
+* Validate that a provider supports the required capabilities for an operation
+* @param provider - The storage provider to validate
+* @param requiredCapabilities - Capabilities required for the operation
+* @throws Error if provider doesn't support required capabilities
+*/
+function validateProviderCapabilities(provider, requiredCapabilities) {
+	const missingCapabilities = requiredCapabilities.filter((capability) => !hasCapability(provider, capability));
+	if (missingCapabilities.length > 0) {
+		const providerName = provider.constructor.name;
+		throw new Error(`Provider ${providerName} does not support required capabilities: ${missingCapabilities.join(", ")}`);
+	}
+}
+/**
+* Get the best provider for a specific use case based on capabilities
+* @param providers - Array of storage providers to choose from
+* @param requiredCapabilities - Capabilities required for the use case
+* @returns The best provider or null if none meet the requirements
+*/
+function getBestProvider(providers, requiredCapabilities) {
+	const suitableProviders = providers.filter((provider) => hasAllCapabilities(provider, requiredCapabilities));
+	if (suitableProviders.length === 0) return null;
+	const edgeCompatible = suitableProviders.filter((provider) => hasCapability(provider, "edgeCompatible"));
+	return edgeCompatible.length > 0 ? edgeCompatible[0] ?? null : suitableProviders[0] ?? null;
+}
+/**
+* Builds a map from provider names to their reported storage capabilities.
+*
+* @param providers - Array of entries each containing a `name` (used as the map key) and a `provider` instance
+* @returns A mapping from each provider name to its `StorageCapabilities`
+*/
+function getCapabilityMatrix(providers) {
+	const matrix = {};
+	for (const { name, provider } of providers) matrix[name] = getProviderCapabilities(provider);
+	return matrix;
+}
+/**
+* Evaluate a storage provider's suitability for a specific file and produce actionable recommendations and warnings.
+*
+* @param provider - The storage provider to evaluate
+* @param fileSize - File size in bytes
+* @param fileType - MIME type of the file
+* @returns An object with `suitable` (`true` if there are no warnings, `false` otherwise), `recommendations` (suggested actions to improve handling), and `warnings` (issues that reduce suitability)
+*/
+function checkProviderSuitability(provider, fileSize, fileType) {
+	const capabilities = getProviderCapabilities(provider);
+	const recommendations = [];
+	const warnings = [];
+	if (fileSize > MULTIPART_THRESHOLDS.SMALL_FILE) if (!capabilities.multipart) warnings.push("Large file detected but provider does not support multipart uploads");
+	else recommendations.push("Use multipart upload for this large file");
+	if (fileType.startsWith("image/")) {
+		if (capabilities.metadata) recommendations.push("Consider storing image metadata for better organization");
+	}
+	if (fileType.startsWith("video/")) {
+		if (!capabilities.multipart) warnings.push("Video files are typically large and benefit from multipart uploads");
+	}
+	if (fileType.startsWith("text/") && !capabilities.edgeCompatible) recommendations.push("Text files could be processed in edge runtime for better performance");
+	return {
+		suitable: warnings.length === 0,
+		recommendations,
+		warnings
+	};
+}
+
+//#endregion
+//#region src/health-check.ts
+/**
+* Check the health of a storage provider
+*
+* @param provider - The storage provider to check
+* @returns Health check result with status and latency
+*/
+async function checkProviderHealth(provider) {
+	const startTime = Date.now();
+	try {
+		await provider.list({ limit: 1 });
+		const latencyMs = Date.now() - startTime;
+		const HEALTHY_THRESHOLD_MS = 1e3;
+		const DEGRADED_THRESHOLD_MS = 3e3;
+		let status;
+		if (latencyMs < HEALTHY_THRESHOLD_MS) status = "healthy";
+		else if (latencyMs < DEGRADED_THRESHOLD_MS) status = "degraded";
+		else status = "unhealthy";
+		return {
+			status,
+			latencyMs,
+			details: {
+				provider: provider.constructor.name,
+				threshold_healthy_ms: HEALTHY_THRESHOLD_MS,
+				threshold_degraded_ms: DEGRADED_THRESHOLD_MS
+			}
+		};
+	} catch (error) {
+		return {
+			status: "unhealthy",
+			latencyMs: Date.now() - startTime,
+			error: error instanceof Error ? error.message : String(error),
+			details: { provider: provider.constructor.name }
+		};
+	}
+}
+/**
+* Perform a comprehensive health check on storage system
+*
+* @param provider - The storage provider to check
+* @returns Detailed health check result
+*/
+async function storageHealthCheck(provider) {
+	return checkProviderHealth(provider);
+}
+
+//#endregion
+export { DEFAULT_STORAGE_CAPABILITIES as _, getBestProvider as a, CloudflareImagesProvider as b, hasAllCapabilities as c, validateProviderCapabilities as d, MultipartUploadManager as f, MultiStorageManager as g, hasMultipartSupport as h, describeProviderCapabilities as i, hasAnyCapability as l, getOptimalPartSize as m, storageHealthCheck as n, getCapabilityMatrix as o, createMultipartUploadManager as p, checkProviderSuitability as r, getProviderCapabilities as s, checkProviderHealth as t, hasCapability as u, STORAGE_CONSTANTS as v, CloudflareR2Provider as y };
+//# sourceMappingURL=health-check-D7LnnDec.mjs.map