@wener/common 2.0.5 → 2.0.6

package/lib/fs/minio/createMinioFileSystem.js

@@ -1,974 +1,977 @@
-import { basename, dirname, normalize } from "pathe";
-import { PassThrough, Readable } from "node:stream";
-import { parseS3Url } from "@wener/common/s3";
-import { Client } from "minio";
+import { PassThrough, Readable } from 'node:stream';
+import { parseS3Url } from '@wener/common/s3';
+import { Client } from 'minio';
+import { basename, dirname, normalize } from 'pathe';
 export function createMinioFileSystem(options = {}) {
-    const parsed = parseS3Url(options);
-    if (!parsed) {
-        throw new Error('S3 URL or connection options are required');
-    }
-    const { client, prefix } = options;
-    if (!client && (!parsed.endpoint || !parsed.bucket)) {
-        throw new Error('S3 endpoint and bucket are required when client is not provided');
-    }
-    let minioClient;
-    let bucket;
-    if (client) {
-        minioClient = client;
-        bucket = parsed.bucket || '';
-    } else {
-        bucket = parsed.bucket || '';
-        // Import Minio dynamically to avoid requiring it as a dependency
-        minioClient = new Client({
-            endPoint: parsed.endpoint,
-            port: parsed.port,
-            useSSL: parsed.useSsl ?? true,
-            accessKey: parsed.accessKeyId || '',
-            secretKey: parsed.secretAccessKey || '',
-            region: parsed.region,
-            pathStyle: parsed.pathStyle
-        });
-    }
-    // Normalize prefix: remove leading/trailing slashes
-    const normalizedPrefix = prefix ? prefix.replace(/^\/+/, '').replace(/\/+$/, '') : '';
-    return new MinioFS(minioClient, bucket, normalizedPrefix);
+	const parsed = parseS3Url(options);
+	if (!parsed) {
+		throw new Error('S3 URL or connection options are required');
+	}
+	const { client, prefix } = options;
+	if (!client && (!parsed.endpoint || !parsed.bucket)) {
+		throw new Error('S3 endpoint and bucket are required when client is not provided');
+	}
+	let minioClient;
+	let bucket;
+	if (client) {
+		minioClient = client;
+		bucket = parsed.bucket || '';
+	} else {
+		bucket = parsed.bucket || '';
+		// Import Minio dynamically to avoid requiring it as a dependency
+		minioClient = new Client({
+			endPoint: parsed.endpoint,
+			port: parsed.port,
+			useSSL: parsed.useSsl ?? true,
+			accessKey: parsed.accessKeyId || '',
+			secretKey: parsed.secretAccessKey || '',
+			region: parsed.region,
+			pathStyle: parsed.pathStyle,
+		});
+	}
+	// Normalize prefix: remove leading/trailing slashes
+	const normalizedPrefix = prefix ? prefix.replace(/^\/+/, '').replace(/\/+$/, '') : '';
+	return new MinioFS(minioClient, bucket, normalizedPrefix);
 }
 let MinioFS = class MinioFS {
-    client;
-    bucket;
-    prefix;
-    constructor(client, bucket, prefix = ''){
-        this.client = client;
-        this.bucket = bucket;
-        this.prefix = prefix;
-    }
-    /**
+	client;
+	bucket;
+	prefix;
+	constructor(client, bucket, prefix = '') {
+		this.client = client;
+		this.bucket = bucket;
+		this.prefix = prefix;
+	}
+	/**
 	 * Normalize path to S3 key format (remove leading slash, handle relative paths)
 	 * and prepend the prefix if one is set
 	 */ normalizeKey(path) {
-        if (!path || path === '/') {
-            return this.prefix;
-        }
-        const normalized = normalize(path).replace(/^\/+/, '').replace(/\\/g, '/');
-        // Prepend prefix if set
-        if (this.prefix) {
-            return this.prefix + '/' + normalized;
-        }
-        return normalized;
-    }
-    /**
+		if (!path || path === '/') {
+			return this.prefix;
+		}
+		const normalized = normalize(path).replace(/^\/+/, '').replace(/\\/g, '/');
+		// Prepend prefix if set
+		if (this.prefix) {
+			return this.prefix + '/' + normalized;
+		}
+		return normalized;
+	}
+	/**
 	 * Remove prefix from S3 key to get the file system path
 	 */ stripPrefix(key) {
-        if (!key) {
-            return '/';
-        }
-        // If key is just the prefix (or empty after stripping), return root
-        if (this.prefix && key === this.prefix) {
-            return '/';
-        }
-        if (!this.prefix || !key.startsWith(this.prefix + '/')) {
-            return key.startsWith('/') ? key : '/' + key;
-        }
-        const withoutPrefix = key.slice(this.prefix.length);
-        return withoutPrefix || '/';
-    }
-    /**
+		if (!key) {
+			return '/';
+		}
+		// If key is just the prefix (or empty after stripping), return root
+		if (this.prefix && key === this.prefix) {
+			return '/';
+		}
+		if (!this.prefix || !key.startsWith(this.prefix + '/')) {
+			return key.startsWith('/') ? key : '/' + key;
+		}
+		const withoutPrefix = key.slice(this.prefix.length);
+		return withoutPrefix || '/';
+	}
+	/**
 	 * Convert S3 key back to file system path (strip prefix and add leading slash)
 	 */ keyToPath(key) {
-        if (!key) {
-            return '/';
-        }
-        return this.stripPrefix(key);
-    }
-    /**
+		if (!key) {
+			return '/';
+		}
+		return this.stripPrefix(key);
+	}
+	/**
 	 * Get directory path from a key
 	 */ getDirectory(key) {
-        if (!key) {
-            return '/';
-        }
-        const dir = dirname(key).replace(/\\/g, '/');
-        return dir === '.' ? '/' : '/' + dir;
-    }
-    /**
+		if (!key) {
+			return '/';
+		}
+		const dir = dirname(key).replace(/\\/g, '/');
+		return dir === '.' ? '/' : '/' + dir;
+	}
+	/**
 	 * Check if a key represents a directory (ends with /)
 	 */ isDirectoryKey(key) {
-        return key.endsWith('/');
-    }
-    /**
+		return key.endsWith('/');
+	}
+	/**
 	 * Convert MinIO object metadata to IFileStat
 	 */ toFileStat(key, obj) {
-        const isDir = this.isDirectoryKey(key);
-        const path = this.keyToPath(key);
-        const directory = this.getDirectory(key);
-        return {
-            directory,
-            path,
-            name: isDir ? basename(key.slice(0, -1)) || basename(directory) || '/' : basename(key),
-            kind: isDir ? 'directory' : 'file',
-            mtime: obj.lastModified ? new Date(obj.lastModified).getTime() : Date.now(),
-            size: obj.size || 0,
-            meta: {
-                ...obj.etag ? {
-                    etag: obj.etag.replace(/"/g, '')
-                } : {}
-            }
-        };
-    }
-    checkAborted(signal) {
-        if (signal?.aborted) {
-            throw new Error('The operation was aborted');
-        }
-    }
-    async readdir(dir, options = {}) {
-        const { glob, recursive, depth = 1, kind, hidden = true, signal } = options;
-        this.checkAborted(signal);
-        const dirPrefix = this.normalizeKey(dir);
-        const prefixWithSlash = dirPrefix ? dirPrefix.endsWith('/') ? dirPrefix : dirPrefix + '/' : '';
-        try {
-            // MinIO listObjects supports recursive option
-            // When recursive=false, MinIO uses delimiter='/' internally to return CommonPrefixes
-            const objects = [];
-            const commonPrefixes = [];
-            // MinIO listObjects returns a stream
-            // When recursive=false, it returns both objects and prefixes (CommonPrefixes)
-            const objectStream = this.client.listObjects(this.bucket, prefixWithSlash, recursive);
-            await new Promise((resolve, reject)=>{
-                objectStream.on('data', (obj)=>{
-                    if (obj.name) {
-                        objects.push({
-                            name: obj.name,
-                            size: obj.size || 0,
-                            lastModified: obj.lastModified || new Date(),
-                            etag: obj.etag || ''
-                        });
-                    } else if (obj.prefix) {
-                        // CommonPrefixes from MinIO
-                        commonPrefixes.push(obj.prefix);
-                    }
-                });
-                objectStream.on('end', ()=>{
-                    resolve();
-                });
-                objectStream.on('error', (err)=>{
-                    reject(err);
-                });
-                if (signal) {
-                    signal.addEventListener('abort', ()=>{
-                        objectStream.destroy();
-                        reject(new Error('The operation was aborted'));
-                    });
-                }
-            });
-            let results = [];
-            // Process CommonPrefixes (directories) first
-            for (const prefix of commonPrefixes){
-                this.checkAborted(signal);
-                // Skip if not under our prefix
-                if (prefixWithSlash && !prefix.startsWith(prefixWithSlash)) {
-                    continue;
-                }
-                // Get relative path
-                const relativePrefix = prefixWithSlash ? prefix.slice(prefixWithSlash.length) : prefix;
-                const dirName = relativePrefix.replace(/\/$/, ''); // Remove trailing slash
-                if (!dirName) continue;
-                // For non-recursive, only show immediate children
-                if (!recursive && depth === 1) {
-                    const firstSlash = dirName.indexOf('/');
-                    if (firstSlash >= 0) {
-                        continue;
-                    }
-                }
-                const dirKey = prefix.endsWith('/') ? prefix : prefix + '/';
-                const stat = this.toFileStat(dirKey, {
-                    name: dirKey,
-                    size: 0,
-                    lastModified: new Date()
-                });
-                // Filter by hidden
-                if (!hidden && stat.name.startsWith('.')) {
-                    continue;
-                }
-                // Filter by kind
-                if (kind && stat.kind !== kind) {
-                    continue;
-                }
-                results.push(stat);
-            }
-            // Process objects (files) to convert to IFileStat
-            const seenDirs = new Set();
-            for (const obj of objects){
-                this.checkAborted(signal);
-                const key = obj.name;
-                if (!key) continue;
-                // Skip if not under our prefix
-                if (prefixWithSlash && !key.startsWith(prefixWithSlash)) {
-                    continue;
-                }
-                // Strip the prefix from the key for path conversion
-                const relativeKey = prefixWithSlash ? key.slice(prefixWithSlash.length) : key;
-                // Calculate depth: count the number of slashes in the relative path
-                // depth=1 means immediate children (no slashes), depth=2 means one level deep (one slash), etc.
-                const depthLevel = (relativeKey.match(/\//g) || []).length + 1;
-                // Filter by depth
-                if (depthLevel > depth) {
-                    continue;
-                }
-                const isDir = this.isDirectoryKey(key);
-                // Track directories to avoid duplicates
-                if (isDir) {
-                    const dirKey = key.slice(0, -1);
-                    if (seenDirs.has(dirKey)) {
-                        continue;
-                    }
-                    seenDirs.add(dirKey);
-                } else {
-                    // For files in recursive mode, always include them
-                    // For non-recursive mode, check if parent directory was already added
-                    if (!recursive) {
-                        const parentDir = dirname(key).replace(/\\/g, '/') + '/';
-                        if (seenDirs.has(parentDir.slice(0, -1))) {
-                            continue;
-                        }
-                    }
-                }
-                const stat = this.toFileStat(key, {
-                    name: key,
-                    size: obj.size || 0,
-                    lastModified: obj.lastModified,
-                    etag: obj.etag
-                });
-                // Filter by hidden
-                if (!hidden && stat.name.startsWith('.')) {
-                    continue;
-                }
-                // Filter by kind
-                if (kind && stat.kind !== kind) {
-                    continue;
-                }
-                results.push(stat);
-            }
-            // Handle recursive with depth > 1
-            if (!recursive && depth > 1) {
-                const subdirs = results.filter((entry)=>entry.kind === 'directory');
-                for (const subdir of subdirs){
-                    this.checkAborted(signal);
-                    const maxDepth = depth - 1;
-                    if (maxDepth > 0) {
-                        const subEntries = await this.readdir(subdir.path, {
-                            ...options,
-                            depth: maxDepth
-                        });
-                        results = [
-                            ...results,
-                            ...subEntries
-                        ];
-                    }
-                }
-            }
-            // Handle glob filtering
-            if (glob) {
-                const { matcher } = await import("micromatch");
-                const match = matcher(glob);
-                results = results.filter((entry)=>match(entry.path));
-            }
-            return results;
-        } catch (error) {
-            if (error.code === 'NoSuchKey' || error.message?.includes('404') || error.code === 'NotFound') {
-                throw new Error(`Directory not found: ${dir}`);
-            }
-            throw error;
-        }
-    }
-    async stat(entry, options = {}) {
-        const { signal } = options;
-        this.checkAborted(signal);
-        const key = this.normalizeKey(entry);
-        if (!key) {
-            // Root directory
-            return {
-                directory: '/',
-                path: '/',
-                name: '/',
-                kind: 'directory',
-                mtime: Date.now(),
-                size: 0,
-                meta: {}
-            };
-        }
-        try {
-            // Try to get object stat
-            const stat = await this.client.statObject(this.bucket, key);
-            return this.toFileStat(key, {
-                name: key,
-                size: stat.size,
-                lastModified: stat.lastModified,
-                etag: stat.etag
-            });
-        } catch (error) {
-            // If object not found, try checking if it's a directory
-            if (error.code === 'NotFound' || error.code === 'NoSuchKey') {
-                const dirKey = key.endsWith('/') ? key : key + '/';
-                try {
-                    // List objects with this prefix to check if it's a directory
-                    const objectStream = this.client.listObjects(this.bucket, dirKey, false);
-                    let hasObjects = false;
-                    await new Promise((resolve, reject)=>{
-                        objectStream.on('data', ()=>{
-                            hasObjects = true;
-                            objectStream.destroy();
-                            resolve();
-                        });
-                        objectStream.on('end', ()=>{
-                            resolve();
-                        });
-                        objectStream.on('error', reject);
-                        if (signal) {
-                            signal.addEventListener('abort', ()=>{
-                                objectStream.destroy();
-                                reject(new Error('The operation was aborted'));
-                            });
-                        }
-                    });
-                    if (hasObjects) {
-                        // It's a directory
-                        return {
-                            directory: this.getDirectory(key),
-                            path: this.keyToPath(key),
-                            name: basename(key.replace(/\/$/, '')) || '/',
-                            kind: 'directory',
-                            mtime: Date.now(),
-                            size: 0,
-                            meta: {}
-                        };
-                    }
-                } catch  {
-                // Ignore listing errors
-                }
-                throw new Error(`File not found: ${entry}`);
-            }
-            throw error;
-        }
-    }
-    async mkdir(path, options = {}) {
-        const { recursive = false, signal } = options;
-        this.checkAborted(signal);
-        // In S3, directories don't actually exist - they're just prefixes
-        // Optionally create a marker object (empty object with trailing slash)
-        const key = this.normalizeKey(path);
-        if (!key) {
-            return; // Root directory, nothing to do
-        }
-        // Ensure it ends with / to indicate directory
-        const dirKey = key.endsWith('/') ? key : key + '/';
-        // Try to create a marker object (0-byte object)
-        try {
-            const stream = new PassThrough();
-            stream.end();
-            await this.client.putObject(this.bucket, dirKey, stream, 0, {
-                'Content-Type': 'application/x-directory'
-            });
-        } catch (error) {
-            // If it already exists or we don't have permission, that's okay for mkdir
-            if (error.code !== 'NoSuchBucket' && error.code !== 'AccessDenied') {
-            // Ignore other errors for mkdir
-            }
-        }
-    }
-    async readFile(path, options = {}) {
-        const { encoding = 'binary', signal, onDownloadProgress } = options;
-        this.checkAborted(signal);
-        const key = this.normalizeKey(path);
-        if (!key) {
-            throw new Error('Cannot read root directory');
-        }
-        try {
-            // MinIO getObject returns Promise<Readable>
-            const nodeStream = await this.client.getObject(this.bucket, key);
-            const chunks = [];
-            let loaded = 0;
-            let total = 0;
-            // Get object size for progress if available
-            try {
-                const stat = await this.client.statObject(this.bucket, key);
-                total = stat.size;
-            } catch  {
-            // Ignore if stat fails
-            }
-            return new Promise((resolve, reject)=>{
-                nodeStream.on('data', (chunk)=>{
-                    chunks.push(chunk);
-                    loaded += chunk.length;
-                    if (onDownloadProgress) {
-                        onDownloadProgress({
-                            loaded,
-                            total: total || -1
-                        });
-                    }
-                });
-                nodeStream.on('end', ()=>{
-                    const buffer = Buffer.concat(chunks);
-                    if (encoding === 'text') {
-                        resolve(buffer.toString('utf-8'));
-                    } else {
-                        resolve(new Uint8Array(buffer));
-                    }
-                });
-                nodeStream.on('error', reject);
-                if (signal) {
-                    signal.addEventListener('abort', ()=>{
-                        if (nodeStream.destroy) {
-                            nodeStream.destroy(new Error('The operation was aborted'));
-                        }
-                        reject(new Error('The operation was aborted'));
-                    });
-                }
-            });
-        } catch (error) {
-            if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
-                throw new Error(`File not found: ${path}`);
-            }
-            throw error;
-        }
-    }
-    async writeFile(path, data, options = {}) {
-        const { signal, overwrite = true, onUploadProgress } = options;
-        this.checkAborted(signal);
-        const key = this.normalizeKey(path);
-        if (!key) {
-            throw new Error('Cannot write to root directory');
-        }
-        // Check if file exists and overwrite is false
-        if (!overwrite) {
-            const exists = await this.exists(path);
-            if (exists) {
-                throw new Error(`File already exists: ${path}`);
-            }
-        }
-        // Convert data to stream or buffer
-        let stream;
-        let size;
-        if (data instanceof Readable) {
-            stream = data;
-            size = 0; // Unknown size
-        } else if (data instanceof ReadableStream) {
-            // Convert Web ReadableStream to Node Readable
-            stream = Readable.fromWeb(data);
-            size = 0;
-        } else {
-            let buffer;
-            if (data instanceof ArrayBuffer) {
-                buffer = Buffer.from(data);
-            } else if (Buffer.isBuffer(data)) {
-                buffer = data;
-            } else if (typeof data === 'string') {
-                buffer = Buffer.from(data, 'utf-8');
-            } else {
-                // ArrayBufferView
-                buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-            }
-            size = buffer.length;
-            stream = new Readable();
-            stream.push(buffer);
-            stream.push(null);
-        }
-        // Wrap stream for progress tracking if needed
-        if (onUploadProgress) {
-            let loaded = 0;
-            const progressStream = new PassThrough();
-            stream.on('data', (chunk)=>{
-                loaded += chunk.length;
-                onUploadProgress({
-                    loaded,
-                    total: size || -1
-                });
-            });
-            stream.pipe(progressStream);
-            stream = progressStream;
-        }
-        try {
-            await this.client.putObject(this.bucket, key, stream, size);
-        } catch (error) {
-            throw error;
-        }
-    }
-    async rm(path, options = {}) {
-        const { recursive = false, force = false, signal } = options;
-        this.checkAborted(signal);
-        const key = this.normalizeKey(path);
-        if (!key) {
-            throw new Error('Cannot remove root directory');
-        }
-        try {
-            if (recursive) {
-                // List all objects with this prefix
-                const prefix = key.endsWith('/') ? key : key + '/';
-                const objectStream = this.client.listObjects(this.bucket, prefix, true);
-                const keys = [];
-                await new Promise((resolve, reject)=>{
-                    objectStream.on('data', (obj)=>{
-                        if (obj.name) {
-                            keys.push(obj.name);
-                        }
-                    });
-                    objectStream.on('end', ()=>{
-                        resolve();
-                    });
-                    objectStream.on('error', reject);
-                    if (signal) {
-                        signal.addEventListener('abort', ()=>{
-                            objectStream.destroy();
-                            reject(new Error('The operation was aborted'));
-                        });
-                    }
-                });
-                // Delete all objects
-                if (keys.length > 0) {
-                    await this.client.removeObjects(this.bucket, keys);
-                }
-                // Also delete the marker object if it exists
-                const markerKey = prefix;
-                try {
-                    await this.client.removeObject(this.bucket, markerKey);
-                } catch  {
-                // Ignore if marker doesn't exist
-                }
-            } else {
-                // Delete single object
-                try {
-                    await this.client.removeObject(this.bucket, key);
-                } catch (error) {
-                    // Check if it's a directory with files
-                    if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
-                        const prefix = key.endsWith('/') ? key : key + '/';
-                        const objectStream = this.client.listObjects(this.bucket, prefix, false);
-                        let hasObjects = false;
-                        await new Promise((resolve)=>{
-                            objectStream.on('data', ()=>{
-                                hasObjects = true;
-                                objectStream.destroy();
-                                resolve();
-                            });
-                            objectStream.on('end', ()=>{
-                                resolve();
-                            });
-                            objectStream.on('error', ()=>{
-                                resolve();
-                            });
-                        });
-                        if (hasObjects) {
-                            if (!force) {
-                                throw new Error('Directory not empty');
-                            }
-                            // If force, delete recursively
-                            const recursiveStream = this.client.listObjects(this.bucket, prefix, true);
-                            const keys = [];
-                            await new Promise((resolve)=>{
-                                recursiveStream.on('data', (obj)=>{
-                                    if (obj.name) {
-                                        keys.push(obj.name);
-                                    }
-                                });
-                                recursiveStream.on('end', ()=>resolve());
-                                recursiveStream.on('error', ()=>resolve());
-                            });
-                            if (keys.length > 0) {
-                                await this.client.removeObjects(this.bucket, keys);
-                            }
-                            // Also try to remove the marker
-                            try {
-                                await this.client.removeObject(this.bucket, prefix);
-                            } catch  {
-                            // Ignore
-                            }
-                        } else {
-                            // File doesn't exist
-                            if (!force) {
-                                throw new Error('File not found');
-                            }
-                            // If force, just return without error
-                            return;
-                        }
-                    } else if (!force) {
-                        throw error;
-                    }
-                }
-            }
-        } catch (error) {
-            if (force && (error.code === 'NoSuchKey' || error.code === 'NotFound')) {
-                return;
-            }
-            if (force && error.message === 'File not found') {
-                return;
-            }
-            throw error;
-        }
-    }
-    async rename(oldPath, newPath, options = {}) {
-        const { signal, overwrite = false } = options;
-        this.checkAborted(signal);
-        const oldKey = this.normalizeKey(oldPath);
-        const newKey = this.normalizeKey(newPath);
-        if (!oldKey) {
-            throw new Error('Cannot rename root directory');
-        }
-        // Check if target exists and overwrite is false
-        if (!overwrite) {
-            const exists = await this.exists(newPath);
-            if (exists) {
-                throw new Error(`Destination already exists: ${newPath}`);
-            }
-        }
-        try {
-            // Check if it's a directory (has objects with prefix)
-            const isDir = oldKey.endsWith('/');
-            const prefix = isDir ? oldKey : oldKey + '/';
-            const objectStream = this.client.listObjects(this.bucket, prefix, true);
-            const objects = [];
-            await new Promise((resolve, reject)=>{
-                objectStream.on('data', (obj)=>{
-                    if (obj.name) {
-                        objects.push({
-                            name: obj.name
-                        });
-                    }
-                });
-                objectStream.on('end', ()=>{
-                    resolve();
-                });
-                objectStream.on('error', reject);
-                if (signal) {
-                    signal.addEventListener('abort', ()=>{
-                        objectStream.destroy();
-                        reject(new Error('The operation was aborted'));
-                    });
-                }
-            });
-            if (objects.length > 0) {
-                // It's a directory or has multiple objects, move all
-                const newPrefix = newKey.endsWith('/') ? newKey : newKey + '/';
-                // Move all objects
-                await Promise.all(objects.map(async (obj)=>{
-                    const objKey = obj.name;
-                    if (!objKey) return;
-                    const relativeKey = objKey.slice(prefix.length);
-                    const newObjKey = newPrefix + relativeKey;
-                    // Copy then delete
-                    // MinIO copyObject signature: copyObject(bucketName, objectName, sourceObject)
-                    // sourceObject should be a string in format "bucket/object"
-                    await this.client.copyObject(this.bucket, newObjKey, `${this.bucket}/${objKey}`);
-                    await this.client.removeObject(this.bucket, objKey);
-                }));
-                // Move marker object if it exists (skip if it's a directory marker with data)
-                try {
-                    // Check if it's a directory marker (ends with /)
-                    if (prefix.endsWith('/')) {
-                        // Try to copy the marker, but skip if it fails due to "contains data payload"
-                        try {
-                            await this.client.copyObject(this.bucket, newPrefix, `${this.bucket}/${prefix}`);
-                            await this.client.removeObject(this.bucket, prefix);
-                        } catch (error) {
-                            // If error is about data payload, just remove the old marker
-                            // Directory markers are optional in S3
-                            if (error.message?.includes('data payload') || error.code === 'InvalidRequest') {
-                                await this.client.removeObject(this.bucket, prefix);
-                            } else {
-                                throw error;
-                            }
-                        }
-                    } else {
-                        await this.client.copyObject(this.bucket, newPrefix, `${this.bucket}/${prefix}`);
-                        await this.client.removeObject(this.bucket, prefix);
-                    }
-                } catch  {
-                // Ignore if marker doesn't exist
-                }
-            } else {
-                // Single file - copy then delete
-                await this.client.copyObject(this.bucket, newKey, `${this.bucket}/${oldKey}`);
-                await this.client.removeObject(this.bucket, oldKey);
-            }
-        } catch (error) {
-            if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
-                throw new Error(`Source file not found: ${oldPath}`);
-            }
-            throw error;
-        }
-    }
-    async exists(path) {
-        try {
-            const key = this.normalizeKey(path);
-            if (!key) {
-                return true; // Root always exists
-            }
-            await this.client.statObject(this.bucket, key);
-            return true;
-        } catch (error) {
-            if (error.code === 'NotFound' || error.code === 'NoSuchKey') {
-                // Check if it's a directory
-                const key = this.normalizeKey(path);
-                const dirKey = key.endsWith('/') ? key : key + '/';
-                try {
-                    const objectStream = this.client.listObjects(this.bucket, dirKey, false);
-                    let hasObjects = false;
-                    await new Promise((resolve)=>{
-                        objectStream.on('data', ()=>{
-                            hasObjects = true;
-                            objectStream.destroy();
-                            resolve();
-                        });
-                        objectStream.on('end', ()=>{
-                            resolve();
-                        });
-                        objectStream.on('error', ()=>{
-                            resolve();
-                        });
-                    });
-                    return hasObjects;
-                } catch  {
-                    return false;
-                }
-            }
-            return false;
-        }
-    }
-    async copy(src, dest, options = {}) {
-        const { signal, overwrite = true, shallow = false } = options;
-        this.checkAborted(signal);
-        const srcKey = this.normalizeKey(src);
-        const destKey = this.normalizeKey(dest);
-        if (!srcKey) {
-            throw new Error('Cannot copy root directory');
-        }
-        // Check if source exists
-        try {
-            const srcStat = await this.stat(src);
-            // Check if destination exists and overwrite is false
-            if (!overwrite) {
-                const exists = await this.exists(dest);
-                if (exists) {
-                    throw new Error(`Destination already exists: ${dest}`);
-                }
-            }
-            if (srcStat.kind === 'directory') {
-                // Copy directory recursively
-                const srcPrefix = srcKey.endsWith('/') ? srcKey : srcKey + '/';
-                const destPrefix = destKey.endsWith('/') ? destKey : destKey + '/';
-                const objectStream = this.client.listObjects(this.bucket, srcPrefix, !shallow);
-                const objects = [];
-                await new Promise((resolve, reject)=>{
-                    objectStream.on('data', (obj)=>{
-                        if (obj.name) {
-                            objects.push({
-                                name: obj.name
-                            });
-                        }
-                    });
-                    objectStream.on('end', ()=>{
-                        resolve();
-                    });
-                    objectStream.on('error', reject);
-                    if (signal) {
-                        signal.addEventListener('abort', ()=>{
-                            objectStream.destroy();
-                            reject(new Error('The operation was aborted'));
-                        });
-                    }
-                });
-                // Copy all objects
-                await Promise.all(objects.map(async (obj)=>{
-                    const objKey = obj.name;
-                    if (!objKey) return;
-                    const relativeKey = objKey.slice(srcPrefix.length);
-                    const newObjKey = destPrefix + relativeKey;
-                    await this.client.copyObject(this.bucket, newObjKey, `${this.bucket}/${objKey}`);
-                }));
-                // Copy marker object if it exists (skip if it's a directory marker with data)
-                try {
-                    // Check if it's a directory marker (ends with /)
-                    if (srcPrefix.endsWith('/')) {
-                        // Try to copy the marker, but skip if it fails due to "contains data payload"
-                        try {
-                            await this.client.copyObject(this.bucket, destPrefix, `${this.bucket}/${srcPrefix}`);
-                        } catch (error) {
-                            // If error is about data payload, just skip copying the marker
-                            // Directory markers are optional in S3
-                            if (!error.message?.includes('data payload') && error.code !== 'InvalidRequest') {
-                                throw error;
-                            }
-                        }
-                    } else {
-                        await this.client.copyObject(this.bucket, destPrefix, `${this.bucket}/${srcPrefix}`);
-                    }
-                } catch  {
-                // Ignore if marker doesn't exist
-                }
-            } else {
-                // Copy single file
-                await this.client.copyObject(this.bucket, destKey, `${this.bucket}/${srcKey}`);
-            }
-        } catch (error) {
-            if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
-                throw new Error(`Source file not found: ${src}`);
-            }
-            throw error;
-        }
-    }
-    createReadStream(path, options = {}) {
-        const key = this.normalizeKey(path);
-        if (!key) {
-            throw new Error('Cannot read root directory');
-        }
-        const { range, signal } = options;
-        // MinIO getObject and getPartialObject both return Promise<Readable>
-        // Create a Readable stream that waits for the promise to resolve
-        const client = this.client;
-        const bucket = this.bucket;
-        const readable = new Readable({
-            async read () {
-                // Only initialize once
-                if (readable._initialized) {
-                    return;
-                }
-                readable._initialized = true;
-                try {
-                    let nodeStream;
-                    if (range) {
-                        // Use getPartialObject for range requests
-                        // getPartialObject's length parameter: number of bytes to read (not end position)
-                        // So for range {start: 0, end: 4}, we need length = end - start + 1 = 5
-                        const length = range.end !== undefined ? range.end - range.start + 1 : undefined;
-                        nodeStream = await client.getPartialObject(bucket, key, range.start, length);
-                    } else {
-                        nodeStream = await client.getObject(bucket, key);
-                    }
-                    // Pipe the actual stream to our readable
-                    nodeStream.on('data', (chunk)=>{
-                        if (!readable.push(chunk)) {
-                            // If push returns false, the stream is backpressured
-                            nodeStream.pause();
-                        }
-                    });
-                    nodeStream.on('end', ()=>{
-                        readable.push(null);
-                    });
-                    nodeStream.on('error', (err)=>{
-                        readable.emit('error', err);
-                    });
-                    if (signal) {
-                        signal.addEventListener('abort', ()=>{
-                            if (nodeStream.destroy) {
-                                nodeStream.destroy(new Error('The operation was aborted'));
-                            }
-                            readable.emit('error', new Error('The operation was aborted'));
-                        });
-                    }
-                } catch (error) {
-                    readable.emit('error', error);
-                }
-            }
-        });
-        return readable;
-    }
-    createReadableStream(path, options = {}) {
-        const key = this.normalizeKey(path);
-        if (!key) {
-            throw new Error('Cannot read root directory');
-        }
-        const { range, signal } = options;
-        // MinIO getObject and getPartialObject both return Promise<Readable>
-        const client = this.client;
-        const bucket = this.bucket;
-        return new ReadableStream({
-            async start (controller) {
-                try {
-                    let nodeStream;
-                    if (range) {
-                        // Use getPartialObject for range requests
-                        // getPartialObject's length parameter: number of bytes to read (not end position)
-                        // So for range {start: 0, end: 4}, we need length = end - start + 1 = 5
-                        const length = range.end !== undefined ? range.end - range.start + 1 : undefined;
-                        nodeStream = await client.getPartialObject(bucket, key, range.start, length);
-                    } else {
-                        nodeStream = await client.getObject(bucket, key);
-                    }
-                    nodeStream.on('data', (chunk)=>{
-                        controller.enqueue(chunk);
-                    });
-                    nodeStream.on('end', ()=>{
-                        controller.close();
-                    });
-                    nodeStream.on('error', (err)=>{
-                        controller.error(err);
-                    });
-                    if (signal) {
-                        signal.addEventListener('abort', ()=>{
-                            if (nodeStream.destroy) {
-                                nodeStream.destroy(new Error('The operation was aborted'));
-                            }
-                            controller.error(new Error('The operation was aborted'));
-                        });
-                    }
-                } catch (error) {
-                    controller.error(error);
-                }
-            }
-        });
-    }
-    createWriteStream(path, options) {
-        throw new Error('Not implemented');
-    }
-    createWritableStream(path, options = {}) {
-        const key = this.normalizeKey(path);
-        if (!key) {
-            throw new Error('Cannot write to root directory');
-        }
-        const { signal, overwrite = true } = options;
-        this.checkAborted(signal);
-        // Create a WritableStream that buffers data and uploads when done
-        const buffer = [];
-        let controller;
-        const client = this.client;
-        const bucket = this.bucket;
-        const checkAborted = this.checkAborted.bind(this);
-        return new WritableStream({
-            start (ctrl) {
-                controller = ctrl;
-            },
-            async write (chunk) {
-                buffer.push(chunk);
-            },
-            async close () {
-                try {
-                    checkAborted(signal);
-                    const data = Buffer.concat(buffer.map((chunk)=>Buffer.from(chunk)));
-                    const stream = new Readable();
-                    stream.push(data);
-                    stream.push(null);
-                    await client.putObject(bucket, key, stream, data.length);
-                // Controller closes automatically when close() completes successfully
-                } catch (error) {
-                    controller.error(error);
-                }
-            },
-            abort (reason) {
-                buffer.length = 0;
-                controller.error(reason);
-            }
-        });
-    }
-    getUrl(path, options) {
-        if (typeof path === 'object' && path?.kind !== 'file') {
-            return;
-        }
-        const key = typeof path === 'string' ? this.normalizeKey(path) : this.normalizeKey(path.path);
-        if (!key) {
-            return;
-        }
-        // MinIO supports presigned URLs, but getUrl is synchronous
-        // We can't generate presigned URLs synchronously, so return undefined
-        // For presigned URLs, users should use a separate method or await the promise
-        return undefined;
-    }
+		const isDir = this.isDirectoryKey(key);
+		const path = this.keyToPath(key);
+		const directory = this.getDirectory(key);
+		return {
+			directory,
+			path,
+			name: isDir ? basename(key.slice(0, -1)) || basename(directory) || '/' : basename(key),
+			kind: isDir ? 'directory' : 'file',
+			mtime: obj.lastModified ? new Date(obj.lastModified).getTime() : Date.now(),
+			size: obj.size || 0,
+			meta: {
+				...(obj.etag
+					? {
+							etag: obj.etag.replace(/"/g, ''),
+						}
+					: {}),
+			},
+		};
+	}
+	checkAborted(signal) {
+		if (signal?.aborted) {
+			throw new Error('The operation was aborted');
+		}
+	}
+	async readdir(dir, options = {}) {
+		const { glob, recursive, depth = 1, kind, hidden = true, signal } = options;
+		this.checkAborted(signal);
+		const dirPrefix = this.normalizeKey(dir);
+		const prefixWithSlash = dirPrefix ? (dirPrefix.endsWith('/') ? dirPrefix : dirPrefix + '/') : '';
+		try {
+			// MinIO listObjects supports recursive option
+			// When recursive=false, MinIO uses delimiter='/' internally to return CommonPrefixes
+			const objects = [];
+			const commonPrefixes = [];
+			// MinIO listObjects returns a stream
+			// When recursive=false, it returns both objects and prefixes (CommonPrefixes)
+			const objectStream = this.client.listObjects(this.bucket, prefixWithSlash, recursive);
+			await new Promise((resolve, reject) => {
+				objectStream.on('data', (obj) => {
+					if (obj.name) {
+						objects.push({
+							name: obj.name,
+							size: obj.size || 0,
+							lastModified: obj.lastModified || new Date(),
+							etag: obj.etag || '',
+						});
+					} else if (obj.prefix) {
+						// CommonPrefixes from MinIO
+						commonPrefixes.push(obj.prefix);
+					}
+				});
+				objectStream.on('end', () => {
+					resolve();
+				});
+				objectStream.on('error', (err) => {
+					reject(err);
+				});
+				if (signal) {
+					signal.addEventListener('abort', () => {
+						objectStream.destroy();
+						reject(new Error('The operation was aborted'));
+					});
+				}
+			});
+			let results = [];
+			// Process CommonPrefixes (directories) first
+			for (const prefix of commonPrefixes) {
+				this.checkAborted(signal);
+				// Skip if not under our prefix
+				if (prefixWithSlash && !prefix.startsWith(prefixWithSlash)) {
+					continue;
+				}
+				// Get relative path
+				const relativePrefix = prefixWithSlash ? prefix.slice(prefixWithSlash.length) : prefix;
+				const dirName = relativePrefix.replace(/\/$/, ''); // Remove trailing slash
+				if (!dirName) continue;
+				// For non-recursive, only show immediate children
+				if (!recursive && depth === 1) {
+					const firstSlash = dirName.indexOf('/');
+					if (firstSlash >= 0) {
+						continue;
+					}
+				}
+				const dirKey = prefix.endsWith('/') ? prefix : prefix + '/';
+				const stat = this.toFileStat(dirKey, {
+					name: dirKey,
+					size: 0,
+					lastModified: new Date(),
+				});
+				// Filter by hidden
+				if (!hidden && stat.name.startsWith('.')) {
+					continue;
+				}
+				// Filter by kind
+				if (kind && stat.kind !== kind) {
+					continue;
+				}
+				results.push(stat);
+			}
+			// Process objects (files) to convert to IFileStat
+			const seenDirs = new Set();
+			for (const obj of objects) {
+				this.checkAborted(signal);
+				const key = obj.name;
+				if (!key) continue;
+				// Skip if not under our prefix
+				if (prefixWithSlash && !key.startsWith(prefixWithSlash)) {
+					continue;
+				}
+				// Strip the prefix from the key for path conversion
+				const relativeKey = prefixWithSlash ? key.slice(prefixWithSlash.length) : key;
+				// Calculate depth: count the number of slashes in the relative path
+				// depth=1 means immediate children (no slashes), depth=2 means one level deep (one slash), etc.
+				const depthLevel = (relativeKey.match(/\//g) || []).length + 1;
+				// Filter by depth
+				if (depthLevel > depth) {
+					continue;
+				}
+				const isDir = this.isDirectoryKey(key);
+				// Track directories to avoid duplicates
+				if (isDir) {
+					const dirKey = key.slice(0, -1);
+					if (seenDirs.has(dirKey)) {
+						continue;
+					}
+					seenDirs.add(dirKey);
+				} else {
+					// For files in recursive mode, always include them
+					// For non-recursive mode, check if parent directory was already added
+					if (!recursive) {
+						const parentDir = dirname(key).replace(/\\/g, '/') + '/';
+						if (seenDirs.has(parentDir.slice(0, -1))) {
+							continue;
+						}
+					}
+				}
+				const stat = this.toFileStat(key, {
+					name: key,
+					size: obj.size || 0,
+					lastModified: obj.lastModified,
+					etag: obj.etag,
+				});
+				// Filter by hidden
+				if (!hidden && stat.name.startsWith('.')) {
+					continue;
+				}
+				// Filter by kind
+				if (kind && stat.kind !== kind) {
+					continue;
+				}
+				results.push(stat);
+			}
+			// Handle recursive with depth > 1
+			if (!recursive && depth > 1) {
+				const subdirs = results.filter((entry) => entry.kind === 'directory');
+				for (const subdir of subdirs) {
+					this.checkAborted(signal);
+					const maxDepth = depth - 1;
+					if (maxDepth > 0) {
+						const subEntries = await this.readdir(subdir.path, {
+							...options,
+							depth: maxDepth,
+						});
+						results = [...results, ...subEntries];
+					}
+				}
+			}
+			// Handle glob filtering
+			if (glob) {
+				const { matcher } = await import('micromatch');
+				const match = matcher(glob);
+				results = results.filter((entry) => match(entry.path));
+			}
+			return results;
+		} catch (error) {
+			if (error.code === 'NoSuchKey' || error.message?.includes('404') || error.code === 'NotFound') {
+				throw new Error(`Directory not found: ${dir}`);
+			}
+			throw error;
+		}
+	}
+	async stat(entry, options = {}) {
+		const { signal } = options;
+		this.checkAborted(signal);
+		const key = this.normalizeKey(entry);
+		if (!key) {
+			// Root directory
+			return {
+				directory: '/',
+				path: '/',
+				name: '/',
+				kind: 'directory',
+				mtime: Date.now(),
+				size: 0,
+				meta: {},
+			};
+		}
+		try {
+			// Try to get object stat
+			const stat = await this.client.statObject(this.bucket, key);
+			return this.toFileStat(key, {
+				name: key,
+				size: stat.size,
+				lastModified: stat.lastModified,
+				etag: stat.etag,
+			});
+		} catch (error) {
+			// If object not found, try checking if it's a directory
+			if (error.code === 'NotFound' || error.code === 'NoSuchKey') {
+				const dirKey = key.endsWith('/') ? key : key + '/';
+				try {
+					// List objects with this prefix to check if it's a directory
+					const objectStream = this.client.listObjects(this.bucket, dirKey, false);
+					let hasObjects = false;
+					await new Promise((resolve, reject) => {
+						objectStream.on('data', () => {
+							hasObjects = true;
+							objectStream.destroy();
+							resolve();
+						});
+						objectStream.on('end', () => {
+							resolve();
+						});
+						objectStream.on('error', reject);
+						if (signal) {
+							signal.addEventListener('abort', () => {
+								objectStream.destroy();
+								reject(new Error('The operation was aborted'));
+							});
+						}
+					});
+					if (hasObjects) {
+						// It's a directory
+						return {
+							directory: this.getDirectory(key),
+							path: this.keyToPath(key),
+							name: basename(key.replace(/\/$/, '')) || '/',
+							kind: 'directory',
+							mtime: Date.now(),
+							size: 0,
+							meta: {},
+						};
+					}
+				} catch {
+					// Ignore listing errors
+				}
+				throw new Error(`File not found: ${entry}`);
+			}
+			throw error;
+		}
+	}
+	async mkdir(path, options = {}) {
+		const { recursive = false, signal } = options;
+		this.checkAborted(signal);
+		// In S3, directories don't actually exist - they're just prefixes
+		// Optionally create a marker object (empty object with trailing slash)
+		const key = this.normalizeKey(path);
+		if (!key) {
+			return; // Root directory, nothing to do
+		}
+		// Ensure it ends with / to indicate directory
+		const dirKey = key.endsWith('/') ? key : key + '/';
+		// Try to create a marker object (0-byte object)
+		try {
+			const stream = new PassThrough();
+			stream.end();
+			await this.client.putObject(this.bucket, dirKey, stream, 0, {
+				'Content-Type': 'application/x-directory',
+			});
+		} catch (error) {
+			// If it already exists or we don't have permission, that's okay for mkdir
+			if (error.code !== 'NoSuchBucket' && error.code !== 'AccessDenied') {
+				// Ignore other errors for mkdir
+			}
+		}
+	}
+	async readFile(path, options = {}) {
+		const { encoding = 'binary', signal, onDownloadProgress } = options;
+		this.checkAborted(signal);
+		const key = this.normalizeKey(path);
+		if (!key) {
+			throw new Error('Cannot read root directory');
+		}
+		try {
+			// MinIO getObject returns Promise<Readable>
+			const nodeStream = await this.client.getObject(this.bucket, key);
+			const chunks = [];
+			let loaded = 0;
+			let total = 0;
+			// Get object size for progress if available
+			try {
+				const stat = await this.client.statObject(this.bucket, key);
+				total = stat.size;
+			} catch {
+				// Ignore if stat fails
+			}
+			return new Promise((resolve, reject) => {
+				nodeStream.on('data', (chunk) => {
+					chunks.push(chunk);
+					loaded += chunk.length;
+					if (onDownloadProgress) {
+						onDownloadProgress({
+							loaded,
+							total: total || -1,
+						});
+					}
+				});
+				nodeStream.on('end', () => {
+					const buffer = Buffer.concat(chunks);
+					if (encoding === 'text') {
+						resolve(buffer.toString('utf-8'));
+					} else {
+						resolve(new Uint8Array(buffer));
+					}
+				});
+				nodeStream.on('error', reject);
+				if (signal) {
+					signal.addEventListener('abort', () => {
+						if (nodeStream.destroy) {
+							nodeStream.destroy(new Error('The operation was aborted'));
+						}
+						reject(new Error('The operation was aborted'));
+					});
+				}
+			});
+		} catch (error) {
+			if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
+				throw new Error(`File not found: ${path}`);
+			}
+			throw error;
+		}
+	}
+	async writeFile(path, data, options = {}) {
+		const { signal, overwrite = true, onUploadProgress } = options;
+		this.checkAborted(signal);
+		const key = this.normalizeKey(path);
+		if (!key) {
+			throw new Error('Cannot write to root directory');
+		}
+		// Check if file exists and overwrite is false
+		if (!overwrite) {
+			const exists = await this.exists(path);
+			if (exists) {
+				throw new Error(`File already exists: ${path}`);
+			}
+		}
+		// Convert data to stream or buffer
+		let stream;
+		let size;
+		if (data instanceof Readable) {
+			stream = data;
+			size = 0; // Unknown size
+		} else if (data instanceof ReadableStream) {
+			// Convert Web ReadableStream to Node Readable
+			stream = Readable.fromWeb(data);
+			size = 0;
+		} else {
+			let buffer;
+			if (data instanceof ArrayBuffer) {
+				buffer = Buffer.from(data);
+			} else if (Buffer.isBuffer(data)) {
+				buffer = data;
+			} else if (typeof data === 'string') {
+				buffer = Buffer.from(data, 'utf-8');
+			} else {
+				// ArrayBufferView
+				buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+			}
+			size = buffer.length;
+			stream = new Readable();
+			stream.push(buffer);
+			stream.push(null);
+		}
+		// Wrap stream for progress tracking if needed
+		if (onUploadProgress) {
+			let loaded = 0;
+			const progressStream = new PassThrough();
+			stream.on('data', (chunk) => {
+				loaded += chunk.length;
+				onUploadProgress({
+					loaded,
+					total: size || -1,
+				});
+			});
+			stream.pipe(progressStream);
+			stream = progressStream;
+		}
+		try {
+			await this.client.putObject(this.bucket, key, stream, size);
+		} catch (error) {
+			throw error;
+		}
+	}
+	async rm(path, options = {}) {
+		const { recursive = false, force = false, signal } = options;
+		this.checkAborted(signal);
+		const key = this.normalizeKey(path);
+		if (!key) {
+			throw new Error('Cannot remove root directory');
+		}
+		try {
+			if (recursive) {
+				// List all objects with this prefix
+				const prefix = key.endsWith('/') ? key : key + '/';
+				const objectStream = this.client.listObjects(this.bucket, prefix, true);
+				const keys = [];
+				await new Promise((resolve, reject) => {
+					objectStream.on('data', (obj) => {
+						if (obj.name) {
+							keys.push(obj.name);
+						}
+					});
+					objectStream.on('end', () => {
+						resolve();
+					});
+					objectStream.on('error', reject);
+					if (signal) {
+						signal.addEventListener('abort', () => {
+							objectStream.destroy();
+							reject(new Error('The operation was aborted'));
+						});
+					}
+				});
+				// Delete all objects
+				if (keys.length > 0) {
+					await this.client.removeObjects(this.bucket, keys);
+				}
+				// Also delete the marker object if it exists
+				const markerKey = prefix;
+				try {
+					await this.client.removeObject(this.bucket, markerKey);
+				} catch {
+					// Ignore if marker doesn't exist
+				}
+			} else {
+				// Delete single object
+				try {
+					await this.client.removeObject(this.bucket, key);
+				} catch (error) {
+					// Check if it's a directory with files
+					if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
+						const prefix = key.endsWith('/') ? key : key + '/';
+						const objectStream = this.client.listObjects(this.bucket, prefix, false);
+						let hasObjects = false;
+						await new Promise((resolve) => {
+							objectStream.on('data', () => {
+								hasObjects = true;
+								objectStream.destroy();
+								resolve();
+							});
+							objectStream.on('end', () => {
+								resolve();
+							});
+							objectStream.on('error', () => {
+								resolve();
+							});
+						});
+						if (hasObjects) {
+							if (!force) {
+								throw new Error('Directory not empty');
+							}
+							// If force, delete recursively
+							const recursiveStream = this.client.listObjects(this.bucket, prefix, true);
+							const keys = [];
+							await new Promise((resolve) => {
+								recursiveStream.on('data', (obj) => {
+									if (obj.name) {
+										keys.push(obj.name);
+									}
+								});
+								recursiveStream.on('end', () => resolve());
+								recursiveStream.on('error', () => resolve());
+							});
+							if (keys.length > 0) {
+								await this.client.removeObjects(this.bucket, keys);
+							}
+							// Also try to remove the marker
+							try {
+								await this.client.removeObject(this.bucket, prefix);
+							} catch {
+								// Ignore
+							}
+						} else {
+							// File doesn't exist
+							if (!force) {
+								throw new Error('File not found');
+							}
+							// If force, just return without error
+							return;
+						}
+					} else if (!force) {
+						throw error;
+					}
+				}
+			}
+		} catch (error) {
+			if (force && (error.code === 'NoSuchKey' || error.code === 'NotFound')) {
+				return;
+			}
+			if (force && error.message === 'File not found') {
+				return;
+			}
+			throw error;
+		}
+	}
+	async rename(oldPath, newPath, options = {}) {
+		const { signal, overwrite = false } = options;
+		this.checkAborted(signal);
+		const oldKey = this.normalizeKey(oldPath);
+		const newKey = this.normalizeKey(newPath);
+		if (!oldKey) {
+			throw new Error('Cannot rename root directory');
+		}
+		// Check if target exists and overwrite is false
+		if (!overwrite) {
+			const exists = await this.exists(newPath);
+			if (exists) {
+				throw new Error(`Destination already exists: ${newPath}`);
+			}
+		}
+		try {
+			// Check if it's a directory (has objects with prefix)
+			const isDir = oldKey.endsWith('/');
+			const prefix = isDir ? oldKey : oldKey + '/';
+			const objectStream = this.client.listObjects(this.bucket, prefix, true);
+			const objects = [];
+			await new Promise((resolve, reject) => {
+				objectStream.on('data', (obj) => {
+					if (obj.name) {
+						objects.push({
+							name: obj.name,
+						});
+					}
+				});
+				objectStream.on('end', () => {
+					resolve();
+				});
+				objectStream.on('error', reject);
+				if (signal) {
+					signal.addEventListener('abort', () => {
+						objectStream.destroy();
+						reject(new Error('The operation was aborted'));
+					});
+				}
+			});
+			if (objects.length > 0) {
+				// It's a directory or has multiple objects, move all
+				const newPrefix = newKey.endsWith('/') ? newKey : newKey + '/';
+				// Move all objects
+				await Promise.all(
+					objects.map(async (obj) => {
+						const objKey = obj.name;
+						if (!objKey) return;
+						const relativeKey = objKey.slice(prefix.length);
+						const newObjKey = newPrefix + relativeKey;
+						// Copy then delete
+						// MinIO copyObject signature: copyObject(bucketName, objectName, sourceObject)
+						// sourceObject should be a string in format "bucket/object"
+						await this.client.copyObject(this.bucket, newObjKey, `${this.bucket}/${objKey}`);
+						await this.client.removeObject(this.bucket, objKey);
+					}),
+				);
+				// Move marker object if it exists (skip if it's a directory marker with data)
+				try {
+					// Check if it's a directory marker (ends with /)
+					if (prefix.endsWith('/')) {
+						// Try to copy the marker, but skip if it fails due to "contains data payload"
+						try {
+							await this.client.copyObject(this.bucket, newPrefix, `${this.bucket}/${prefix}`);
+							await this.client.removeObject(this.bucket, prefix);
+						} catch (error) {
+							// If error is about data payload, just remove the old marker
+							// Directory markers are optional in S3
+							if (error.message?.includes('data payload') || error.code === 'InvalidRequest') {
+								await this.client.removeObject(this.bucket, prefix);
+							} else {
+								throw error;
+							}
+						}
+					} else {
+						await this.client.copyObject(this.bucket, newPrefix, `${this.bucket}/${prefix}`);
+						await this.client.removeObject(this.bucket, prefix);
+					}
+				} catch {
+					// Ignore if marker doesn't exist
+				}
+			} else {
+				// Single file - copy then delete
+				await this.client.copyObject(this.bucket, newKey, `${this.bucket}/${oldKey}`);
+				await this.client.removeObject(this.bucket, oldKey);
+			}
+		} catch (error) {
+			if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
+				throw new Error(`Source file not found: ${oldPath}`);
+			}
+			throw error;
+		}
+	}
+	async exists(path) {
+		try {
+			const key = this.normalizeKey(path);
+			if (!key) {
+				return true; // Root always exists
+			}
+			await this.client.statObject(this.bucket, key);
+			return true;
+		} catch (error) {
+			if (error.code === 'NotFound' || error.code === 'NoSuchKey') {
+				// Check if it's a directory
+				const key = this.normalizeKey(path);
+				const dirKey = key.endsWith('/') ? key : key + '/';
+				try {
+					const objectStream = this.client.listObjects(this.bucket, dirKey, false);
+					let hasObjects = false;
+					await new Promise((resolve) => {
+						objectStream.on('data', () => {
+							hasObjects = true;
+							objectStream.destroy();
+							resolve();
+						});
+						objectStream.on('end', () => {
+							resolve();
+						});
+						objectStream.on('error', () => {
+							resolve();
+						});
+					});
+					return hasObjects;
+				} catch {
+					return false;
+				}
+			}
+			return false;
+		}
+	}
+	async copy(src, dest, options = {}) {
+		const { signal, overwrite = true, shallow = false } = options;
+		this.checkAborted(signal);
+		const srcKey = this.normalizeKey(src);
+		const destKey = this.normalizeKey(dest);
+		if (!srcKey) {
+			throw new Error('Cannot copy root directory');
+		}
+		// Check if source exists
+		try {
+			const srcStat = await this.stat(src);
+			// Check if destination exists and overwrite is false
+			if (!overwrite) {
+				const exists = await this.exists(dest);
+				if (exists) {
+					throw new Error(`Destination already exists: ${dest}`);
+				}
+			}
+			if (srcStat.kind === 'directory') {
+				// Copy directory recursively
+				const srcPrefix = srcKey.endsWith('/') ? srcKey : srcKey + '/';
+				const destPrefix = destKey.endsWith('/') ? destKey : destKey + '/';
+				const objectStream = this.client.listObjects(this.bucket, srcPrefix, !shallow);
+				const objects = [];
+				await new Promise((resolve, reject) => {
+					objectStream.on('data', (obj) => {
+						if (obj.name) {
+							objects.push({
+								name: obj.name,
+							});
+						}
+					});
+					objectStream.on('end', () => {
+						resolve();
+					});
+					objectStream.on('error', reject);
+					if (signal) {
+						signal.addEventListener('abort', () => {
+							objectStream.destroy();
+							reject(new Error('The operation was aborted'));
+						});
+					}
+				});
+				// Copy all objects
+				await Promise.all(
+					objects.map(async (obj) => {
+						const objKey = obj.name;
+						if (!objKey) return;
+						const relativeKey = objKey.slice(srcPrefix.length);
+						const newObjKey = destPrefix + relativeKey;
+						await this.client.copyObject(this.bucket, newObjKey, `${this.bucket}/${objKey}`);
+					}),
+				);
+				// Copy marker object if it exists (skip if it's a directory marker with data)
+				try {
+					// Check if it's a directory marker (ends with /)
+					if (srcPrefix.endsWith('/')) {
+						// Try to copy the marker, but skip if it fails due to "contains data payload"
+						try {
+							await this.client.copyObject(this.bucket, destPrefix, `${this.bucket}/${srcPrefix}`);
+						} catch (error) {
+							// If error is about data payload, just skip copying the marker
+							// Directory markers are optional in S3
+							if (!error.message?.includes('data payload') && error.code !== 'InvalidRequest') {
+								throw error;
+							}
+						}
+					} else {
+						await this.client.copyObject(this.bucket, destPrefix, `${this.bucket}/${srcPrefix}`);
+					}
+				} catch {
+					// Ignore if marker doesn't exist
+				}
+			} else {
+				// Copy single file
+				await this.client.copyObject(this.bucket, destKey, `${this.bucket}/${srcKey}`);
+			}
+		} catch (error) {
+			if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
+				throw new Error(`Source file not found: ${src}`);
+			}
+			throw error;
+		}
+	}
+	createReadStream(path, options = {}) {
+		const key = this.normalizeKey(path);
+		if (!key) {
+			throw new Error('Cannot read root directory');
+		}
+		const { range, signal } = options;
+		// MinIO getObject and getPartialObject both return Promise<Readable>
+		// Create a Readable stream that waits for the promise to resolve
+		const client = this.client;
+		const bucket = this.bucket;
+		const readable = new Readable({
+			async read() {
+				// Only initialize once
+				if (readable._initialized) {
+					return;
+				}
+				readable._initialized = true;
+				try {
+					let nodeStream;
+					if (range) {
+						// Use getPartialObject for range requests
+						// getPartialObject's length parameter: number of bytes to read (not end position)
+						// So for range {start: 0, end: 4}, we need length = end - start + 1 = 5
+						const length = range.end !== undefined ? range.end - range.start + 1 : undefined;
+						nodeStream = await client.getPartialObject(bucket, key, range.start, length);
+					} else {
+						nodeStream = await client.getObject(bucket, key);
+					}
+					// Pipe the actual stream to our readable
+					nodeStream.on('data', (chunk) => {
+						if (!readable.push(chunk)) {
+							// If push returns false, the stream is backpressured
+							nodeStream.pause();
+						}
+					});
+					nodeStream.on('end', () => {
+						readable.push(null);
+					});
+					nodeStream.on('error', (err) => {
+						readable.emit('error', err);
+					});
+					if (signal) {
+						signal.addEventListener('abort', () => {
+							if (nodeStream.destroy) {
+								nodeStream.destroy(new Error('The operation was aborted'));
+							}
+							readable.emit('error', new Error('The operation was aborted'));
+						});
+					}
+				} catch (error) {
+					readable.emit('error', error);
+				}
+			},
+		});
+		return readable;
+	}
+	createReadableStream(path, options = {}) {
+		const key = this.normalizeKey(path);
+		if (!key) {
+			throw new Error('Cannot read root directory');
+		}
+		const { range, signal } = options;
+		// MinIO getObject and getPartialObject both return Promise<Readable>
+		const client = this.client;
+		const bucket = this.bucket;
+		return new ReadableStream({
+			async start(controller) {
+				try {
+					let nodeStream;
+					if (range) {
+						// Use getPartialObject for range requests
+						// getPartialObject's length parameter: number of bytes to read (not end position)
+						// So for range {start: 0, end: 4}, we need length = end - start + 1 = 5
+						const length = range.end !== undefined ? range.end - range.start + 1 : undefined;
+						nodeStream = await client.getPartialObject(bucket, key, range.start, length);
+					} else {
+						nodeStream = await client.getObject(bucket, key);
+					}
+					nodeStream.on('data', (chunk) => {
+						controller.enqueue(chunk);
+					});
+					nodeStream.on('end', () => {
+						controller.close();
+					});
+					nodeStream.on('error', (err) => {
+						controller.error(err);
+					});
+					if (signal) {
+						signal.addEventListener('abort', () => {
+							if (nodeStream.destroy) {
+								nodeStream.destroy(new Error('The operation was aborted'));
+							}
+							controller.error(new Error('The operation was aborted'));
+						});
+					}
+				} catch (error) {
+					controller.error(error);
+				}
+			},
+		});
+	}
+	createWriteStream(path, options) {
+		throw new Error('Not implemented');
+	}
+	createWritableStream(path, options = {}) {
+		const key = this.normalizeKey(path);
+		if (!key) {
+			throw new Error('Cannot write to root directory');
+		}
+		const { signal, overwrite = true } = options;
+		this.checkAborted(signal);
+		// Create a WritableStream that buffers data and uploads when done
+		const buffer = [];
+		let controller;
+		const client = this.client;
+		const bucket = this.bucket;
+		const checkAborted = this.checkAborted.bind(this);
+		return new WritableStream({
+			start(ctrl) {
+				controller = ctrl;
+			},
+			async write(chunk) {
+				buffer.push(chunk);
+			},
+			async close() {
+				try {
+					checkAborted(signal);
+					const data = Buffer.concat(buffer.map((chunk) => Buffer.from(chunk)));
+					const stream = new Readable();
+					stream.push(data);
+					stream.push(null);
+					await client.putObject(bucket, key, stream, data.length);
+					// Controller closes automatically when close() completes successfully
+				} catch (error) {
+					controller.error(error);
+				}
+			},
+			abort(reason) {
+				buffer.length = 0;
+				controller.error(reason);
+			},
+		});
+	}
+	getUrl(path, options) {
+		if (typeof path === 'object' && path?.kind !== 'file') {
+			return;
+		}
+		const key = typeof path === 'string' ? this.normalizeKey(path) : this.normalizeKey(path.path);
+		if (!key) {
+			return;
+		}
+		// MinIO supports presigned URLs, but getUrl is synchronous
+		// We can't generate presigned URLs synchronously, so return undefined
+		// For presigned URLs, users should use a separate method or await the promise
+		return undefined;
+	}
 };
 
-//# sourceMappingURL=createMinioFileSystem.js.map
+//# sourceMappingURL=createMinioFileSystem.js.map