@statewalker/webrun-files-s3 0.5.0 → 0.9.0

package/dist/esm/index.js

@@ -1,353 +1,162 @@
-import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CopyObjectCommand, CreateMultipartUploadCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, UploadPartCommand, UploadPartCopyCommand } from "@aws-sdk/client-s3";
-import { basename, resolveFileRef, toBinaryAsyncIterable } from "@statewalker/webrun-files";
-
-//#region src/s3-file-handle.ts
+import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CopyObjectCommand, CreateMultipartUploadCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, UploadPartCommand } from "@aws-sdk/client-s3";
+import { basename, normalizePath } from "@statewalker/webrun-files";
+//#region src/s3-files-api.ts
+/** Default part size for multipart uploads: 5MB (S3 minimum) */
+const DEFAULT_PART_SIZE = 5242880;
+/** Threshold for using multipart upload: 5MB */
+const MULTIPART_THRESHOLD = 5242880;
 /**
-* Helper to stream S3 response body as async iterable of Uint8Array chunks.
-* Handles both Node.js Readable streams and browser ReadableStreams.
-* Yields chunks as they arrive without buffering the entire response.
+* S3 filesystem implementation of FilesApi.
+*
+* Provides a filesystem-like interface over S3 object storage.
+* Works with AWS S3 and S3-compatible services.
 */
-async function* streamBody(body) {
-	if (!body) return;
-	if (Symbol.asyncIterator in body) {
-		for await (const chunk of body) yield chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
-		return;
-	}
-	if (body instanceof Uint8Array) {
-		yield body;
-		return;
-	}
-	if (body instanceof ArrayBuffer) {
-		yield new Uint8Array(body);
-		return;
-	}
-	throw new Error("Unsupported body type");
-}
-var S3FileHandle = class {
+var S3FilesApi = class {
 	client;
 	bucket;
-	key;
-	_size;
-	multipartPartSize;
-	closed = false;
+	prefix;
+	partSize;
 	constructor(options) {
 		this.client = options.client;
 		this.bucket = options.bucket;
-		this.key = options.key;
-		this._size = options.size;
-		this.multipartPartSize = options.multipartPartSize;
-	}
-	get size() {
-		return this._size;
+		this.prefix = (options.prefix ?? "").replace(/^\/+|\/+$/g, "");
+		this.partSize = options.multipartPartSize ?? DEFAULT_PART_SIZE;
 	}
-	async close() {
-		this.closed = true;
+	resolveKey(path) {
+		const normalized = normalizePath(path);
+		const relativePath = normalized.startsWith("/") ? normalized.substring(1) : normalized;
+		if (this.prefix) return relativePath ? `${this.prefix}/${relativePath}` : this.prefix;
+		return relativePath;
 	}
-	/**
-	* Reads a range of bytes from the S3 object.
-	* Uses HTTP Range header for efficient partial reads.
-	* Streams data directly from S3 without buffering the entire response.
-	*/
-	async *createReadStream(options = {}) {
-		if (this.closed) throw new Error("FileHandle is closed");
-		const { start = 0, end = Infinity, signal } = options;
-		const actualEnd = Math.min(end, this._size);
-		if (start >= actualEnd || this._size === 0) return;
-		const command = new GetObjectCommand({
-			Bucket: this.bucket,
-			Key: this.key,
-			Range: `bytes=${start}-${actualEnd - 1}`
-		});
-		const response = await this.client.send(command, { abortSignal: signal });
-		if (!response.Body) return;
-		for await (const chunk of streamBody(response.Body)) {
-			if (signal?.aborted) throw new Error("Operation aborted");
-			yield chunk;
+	keyToPath(key) {
+		let relativePath = key;
+		if (this.prefix && key.startsWith(this.prefix)) {
+			relativePath = key.substring(this.prefix.length);
+			if (relativePath.startsWith("/")) relativePath = relativePath.substring(1);
 		}
+		return `/${relativePath}`;
 	}
-	/**
-	* Writes content to the S3 object using streaming.
-	*
-	* S3 objects are immutable, so this operation replaces the entire object.
-	* Uses streaming multipart upload to avoid buffering the entire file in memory.
-	* Only buffers one part at a time (5MB by default).
-	*
-	* Note: start position > 0 uses UploadPartCopy to preserve existing content
-	* without downloading it.
-	*/
-	async createWriteStream(data, options = {}) {
-		if (this.closed) throw new Error("FileHandle is closed");
-		const { start = 0, signal } = options;
-		return this.streamingMultipartUpload(data, start, signal);
-	}
-	/**
-	* Appends content to the end of the S3 object using streaming.
-	*
-	* Uses UploadPartCopy to preserve existing content without downloading it,
-	* then streams new data as additional parts.
-	*/
-	async appendFile(data, options = {}) {
-		if (this.closed) throw new Error("FileHandle is closed");
-		const { signal } = options;
-		return this.streamingMultipartUpload(data, this._size, signal);
+	async *read(path, options) {
+		const key = this.resolveKey(path);
+		try {
+			const start = options?.start ?? 0;
+			const length = options?.length;
+			if (length === 0) return;
+			let range;
+			if (start > 0 || length !== void 0) range = `bytes=${start}-${length !== void 0 ? start + length - 1 : ""}`;
+			const command = new GetObjectCommand({
+				Bucket: this.bucket,
+				Key: key,
+				Range: range
+			});
+			const response = await this.client.send(command);
+			if (response.Body) {
+				const stream = response.Body;
+				for await (const chunk of stream) yield chunk;
+			}
+		} catch (error) {
+			const err = error;
+			if (err.name === "NotFound" || err.name === "InvalidRange" || err.$metadata?.httpStatusCode === 404 || err.$metadata?.httpStatusCode === 416) return;
+			throw error;
+		}
 	}
-	/**
-	* Streaming multipart upload that buffers only one part at a time.
-	* Uses UploadPartCopy to preserve existing content without downloading it
-	* for large files. For small existing content (< part size), downloads and
-	* combines with new data to meet S3's minimum part size requirement.
-	*/
-	async streamingMultipartUpload(data, start, signal) {
-		const createCommand = new CreateMultipartUploadCommand({
-			Bucket: this.bucket,
-			Key: this.key
-		});
-		const { UploadId } = await this.client.send(createCommand, { abortSignal: signal });
-		if (!UploadId) throw new Error("Failed to initiate multipart upload");
+	async write(path, content) {
+		const key = this.resolveKey(path);
+		let buffer = [];
+		let bufferSize = 0;
+		let uploadId;
 		const parts = [];
 		let partNumber = 1;
-		let bytesWritten = 0;
-		let totalSize = 0;
-		let buffer = new Uint8Array(this.multipartPartSize);
-		let bufferOffset = 0;
-		try {
-			if (start > 0 && this._size > 0) {
-				const preserveEnd = Math.min(start, this._size);
-				const fullPartsEnd = Math.floor(preserveEnd / this.multipartPartSize) * this.multipartPartSize;
-				let copyOffset = 0;
-				while (copyOffset < fullPartsEnd) {
-					if (signal?.aborted) throw new Error("Operation aborted");
-					const copyEnd = copyOffset + this.multipartPartSize;
-					const copyCommand = new UploadPartCopyCommand({
-						Bucket: this.bucket,
-						Key: this.key,
-						UploadId,
-						PartNumber: partNumber,
-						CopySource: `${this.bucket}/${this.key}`,
-						CopySourceRange: `bytes=${copyOffset}-${copyEnd - 1}`
-					});
-					const { CopyPartResult } = await this.client.send(copyCommand, { abortSignal: signal });
-					if (CopyPartResult?.ETag) {
-						parts.push({
-							ETag: CopyPartResult.ETag,
-							PartNumber: partNumber
-						});
-						partNumber++;
-						totalSize += this.multipartPartSize;
-					}
-					copyOffset = copyEnd;
-				}
-				if (fullPartsEnd < preserveEnd) {
-					const remainingBytes = await this.downloadRange(fullPartsEnd, preserveEnd, signal);
-					buffer.set(remainingBytes, bufferOffset);
-					bufferOffset += remainingBytes.length;
-					totalSize += remainingBytes.length;
-				}
-				if (start > this._size) {
-					const paddingSize = start - this._size;
-					let paddingOffset = 0;
-					while (paddingOffset < paddingSize) {
-						const spaceInBuffer = this.multipartPartSize - bufferOffset;
-						const bytesToAdd = Math.min(spaceInBuffer, paddingSize - paddingOffset);
-						bufferOffset += bytesToAdd;
-						paddingOffset += bytesToAdd;
-						totalSize += bytesToAdd;
-						if (bufferOffset >= this.multipartPartSize) {
-							await this.uploadPart(UploadId, partNumber, buffer, parts, signal);
-							partNumber++;
-							buffer = new Uint8Array(this.multipartPartSize);
-							bufferOffset = 0;
-						}
-					}
-				}
-			} else if (start > 0) {
-				let paddingOffset = 0;
-				while (paddingOffset < start) {
-					const spaceInBuffer = this.multipartPartSize - bufferOffset;
-					const bytesToAdd = Math.min(spaceInBuffer, start - paddingOffset);
-					bufferOffset += bytesToAdd;
-					paddingOffset += bytesToAdd;
-					totalSize += bytesToAdd;
-					if (bufferOffset >= this.multipartPartSize) {
-						await this.uploadPart(UploadId, partNumber, buffer, parts, signal);
-						partNumber++;
-						buffer = new Uint8Array(this.multipartPartSize);
-						bufferOffset = 0;
-					}
-				}
+		const flushPart = async (isLast) => {
+			if (buffer.length === 0) return;
+			const partLength = buffer.reduce((sum, c) => sum + c.length, 0);
+			const partBuffer = new Uint8Array(partLength);
+			let offset = 0;
+			for (const chunk of buffer) {
+				partBuffer.set(chunk, offset);
+				offset += chunk.length;
 			}
-			for await (const chunk of toBinaryAsyncIterable(data)) {
-				if (signal?.aborted) throw new Error("Operation aborted");
-				let chunkOffset = 0;
-				while (chunkOffset < chunk.length) {
-					const spaceInBuffer = this.multipartPartSize - bufferOffset;
-					const bytesToCopy = Math.min(spaceInBuffer, chunk.length - chunkOffset);
-					buffer.set(chunk.subarray(chunkOffset, chunkOffset + bytesToCopy), bufferOffset);
-					bufferOffset += bytesToCopy;
-					chunkOffset += bytesToCopy;
-					bytesWritten += bytesToCopy;
-					totalSize += bytesToCopy;
-					if (bufferOffset >= this.multipartPartSize) {
-						await this.uploadPart(UploadId, partNumber, buffer, parts, signal);
-						partNumber++;
-						buffer = new Uint8Array(this.multipartPartSize);
-						bufferOffset = 0;
-					}
-				}
+			buffer = [];
+			bufferSize = 0;
+			if (!uploadId && isLast && partLength < MULTIPART_THRESHOLD) {
+				const command = new PutObjectCommand({
+					Bucket: this.bucket,
+					Key: key,
+					Body: partBuffer,
+					ContentLength: partLength
+				});
+				await this.client.send(command);
+				return;
 			}
-			if (bufferOffset > 0) {
-				const lastPart = buffer.subarray(0, bufferOffset);
-				await this.uploadPart(UploadId, partNumber, lastPart, parts, signal);
+			if (!uploadId) {
+				const createCommand = new CreateMultipartUploadCommand({
+					Bucket: this.bucket,
+					Key: key
+				});
+				const { UploadId } = await this.client.send(createCommand);
+				if (!UploadId) throw new Error("Failed to create multipart upload");
+				uploadId = UploadId;
 			}
-			if (parts.length === 0) await this.uploadPart(UploadId, 1, new Uint8Array(0), parts, signal);
-			const completeCommand = new CompleteMultipartUploadCommand({
+			const uploadCommand = new UploadPartCommand({
 				Bucket: this.bucket,
-				Key: this.key,
-				UploadId,
-				MultipartUpload: { Parts: parts }
+				Key: key,
+				UploadId: uploadId,
+				PartNumber: partNumber,
+				Body: partBuffer
+			});
+			const response = await this.client.send(uploadCommand);
+			if (!response.ETag) throw new Error(`Failed to upload part ${partNumber}`);
+			parts.push({
+				ETag: response.ETag,
+				PartNumber: partNumber
 			});
-			await this.client.send(completeCommand, { abortSignal: signal });
-			this._size = totalSize;
-			return bytesWritten;
+			partNumber++;
+		};
+		try {
+			for await (const chunk of content) {
+				buffer.push(chunk);
+				bufferSize += chunk.length;
+				if (bufferSize >= this.partSize) await flushPart(false);
+			}
+			await flushPart(true);
+			if (uploadId) {
+				const completeCommand = new CompleteMultipartUploadCommand({
+					Bucket: this.bucket,
+					Key: key,
+					UploadId: uploadId,
+					MultipartUpload: { Parts: parts.sort((a, b) => a.PartNumber - b.PartNumber) }
+				});
+				await this.client.send(completeCommand);
+			}
 		} catch (error) {
-			await this.abortMultipartUpload(UploadId);
+			if (uploadId) {
+				const abortCommand = new AbortMultipartUploadCommand({
+					Bucket: this.bucket,
+					Key: key,
+					UploadId: uploadId
+				});
+				try {
+					await this.client.send(abortCommand);
+				} catch {}
+			}
 			throw error;
 		}
 	}
-	/**
-	* Download a range of bytes from the S3 object.
-	*/
-	async downloadRange(start, end, signal) {
-		if (end <= start) return new Uint8Array(0);
-		const command = new GetObjectCommand({
-			Bucket: this.bucket,
-			Key: this.key,
-			Range: `bytes=${start}-${end - 1}`
-		});
-		const response = await this.client.send(command, { abortSignal: signal });
-		if (!response.Body) return new Uint8Array(0);
-		const chunks = [];
-		for await (const chunk of streamBody(response.Body)) chunks.push(chunk);
-		if (chunks.length === 0) return new Uint8Array(0);
-		if (chunks.length === 1) return chunks[0];
-		const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
-		const result = new Uint8Array(totalLength);
-		let offset = 0;
-		for (const chunk of chunks) {
-			result.set(chunk, offset);
-			offset += chunk.length;
-		}
-		return result;
-	}
-	/**
-	* Upload a single part and record it in the parts array.
-	*/
-	async uploadPart(uploadId, partNumber, data, parts, signal) {
-		const command = new UploadPartCommand({
-			Bucket: this.bucket,
-			Key: this.key,
-			UploadId: uploadId,
-			PartNumber: partNumber,
-			Body: data,
-			ContentLength: data.length
-		});
-		const { ETag } = await this.client.send(command, { abortSignal: signal });
-		if (ETag) parts.push({
-			ETag,
-			PartNumber: partNumber
-		});
-	}
-	/**
-	* Abort a multipart upload, ignoring errors.
-	*/
-	async abortMultipartUpload(uploadId) {
-		const command = new AbortMultipartUploadCommand({
-			Bucket: this.bucket,
-			Key: this.key,
-			UploadId: uploadId
-		});
-		await this.client.send(command).catch(() => {});
-	}
-	/**
-	* Random access read from S3 object using HTTP Range header.
-	*/
-	async read(buffer, offset, length, position) {
-		if (this.closed) throw new Error("FileHandle is closed");
-		let len = Math.min(length, buffer.length - offset);
-		len = Math.min(len, this._size - position);
-		len = Math.max(0, len);
-		if (len === 0) return 0;
-		const command = new GetObjectCommand({
+	async mkdir(path) {
+		const key = this.resolveKey(path);
+		const dirKey = key.endsWith("/") ? key : `${key}/`;
+		const command = new PutObjectCommand({
 			Bucket: this.bucket,
-			Key: this.key,
-			Range: `bytes=${position}-${position + len - 1}`
+			Key: dirKey,
+			Body: /* @__PURE__ */ new Uint8Array(0),
+			ContentLength: 0
 		});
-		const response = await this.client.send(command);
-		if (!response.Body) return 0;
-		const chunks = [];
-		for await (const chunk of streamBody(response.Body)) chunks.push(chunk);
-		if (chunks.length === 0) return 0;
-		let data;
-		if (chunks.length === 1) data = chunks[0];
-		else {
-			const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
-			data = new Uint8Array(totalLength);
-			let pos = 0;
-			for (const chunk of chunks) {
-				data.set(chunk, pos);
-				pos += chunk.length;
-			}
-		}
-		const bytesToCopy = Math.min(data.length, len);
-		buffer.set(data.subarray(0, bytesToCopy), offset);
-		return bytesToCopy;
-	}
-};
-
-//#endregion
-//#region src/s3-files-api.ts
-var S3FilesApi = class {
-	client;
-	bucket;
-	prefix;
-	multipartPartSize;
-	constructor(options) {
-		this.client = options.client;
-		this.bucket = options.bucket;
-		this.prefix = (options.prefix ?? "").replace(/^\/+|\/+$/g, "");
-		this.multipartPartSize = options.multipartPartSize ?? 5 * 1024 * 1024;
-	}
-	/**
-	* Converts a virtual path to an S3 key.
-	* @example resolveKey("/docs/file.txt") => "prefix/docs/file.txt"
-	*/
-	resolveKey(file) {
-		const normalized = resolveFileRef(file);
-		const relativePath = normalized.startsWith("/") ? normalized.substring(1) : normalized;
-		if (this.prefix) return relativePath ? `${this.prefix}/${relativePath}` : this.prefix;
-		return relativePath;
-	}
-	/**
-	* Converts an S3 key back to a virtual path.
-	*/
-	keyToPath(key) {
-		let relativePath = key;
-		if (this.prefix && key.startsWith(this.prefix)) {
-			relativePath = key.substring(this.prefix.length);
-			if (relativePath.startsWith("/")) relativePath = relativePath.substring(1);
-		}
-		return "/" + relativePath;
+		await this.client.send(command);
 	}
-	/**
-	* Lists objects in a virtual directory.
-	*
-	* Uses S3's delimiter feature to simulate directory listing.
-	* CommonPrefixes represent subdirectories.
-	*/
-	async *list(file, options = {}) {
-		const { recursive = false } = options;
-		const prefix = this.resolveKey(file);
-		const normalizedPrefix = prefix ? prefix + "/" : this.prefix ? this.prefix + "/" : "";
+	async *list(path, options) {
+		const recursive = options?.recursive ?? false;
+		const prefix = this.resolveKey(path);
+		const normalizedPrefix = prefix ? `${prefix}/` : this.prefix ? `${this.prefix}/` : "";
 		let continuationToken;
 		do {
 			const command = new ListObjectsV2Command({
@@ -361,24 +170,23 @@ var S3FilesApi = class {
 			if (!recursive && response.CommonPrefixes) for (const cpPrefix of response.CommonPrefixes) {
 				if (!cpPrefix.Prefix) continue;
 				const dirKey = cpPrefix.Prefix.endsWith("/") ? cpPrefix.Prefix.slice(0, -1) : cpPrefix.Prefix;
-				const path = this.keyToPath(dirKey);
+				const dirPath = this.keyToPath(dirKey);
 				yield {
 					kind: "directory",
-					name: basename(path),
-					path,
-					lastModified: 0
+					name: basename(dirPath),
+					path: dirPath
 				};
 			}
 			if (response.Contents) for (const obj of response.Contents) {
 				if (!obj.Key) continue;
 				if (obj.Key === normalizedPrefix) continue;
-				if (obj.Key + "/" === normalizedPrefix) continue;
+				if (`${obj.Key}/` === normalizedPrefix) continue;
 				if (obj.Key.endsWith("/")) continue;
-				const path = this.keyToPath(obj.Key);
+				const filePath = this.keyToPath(obj.Key);
 				yield {
 					kind: "file",
-					name: basename(path),
-					path,
+					name: basename(filePath),
+					path: filePath,
 					size: obj.Size ?? 0,
 					lastModified: obj.LastModified?.getTime() ?? 0
 				};
@@ -386,18 +194,10 @@ var S3FilesApi = class {
 			continuationToken = response.NextContinuationToken;
 		} while (continuationToken);
 	}
-	/**
-	* Gets object metadata using HEAD request.
-	*/
-	async stats(file) {
-		const normalized = resolveFileRef(file);
-		const key = this.resolveKey(file);
-		if (normalized === "/") return {
-			kind: "directory",
-			name: "",
-			path: "/",
-			lastModified: 0
-		};
+	async stats(path) {
+		const normalized = normalizePath(path);
+		const key = this.resolveKey(path);
+		if (normalized === "/") return { kind: "directory" };
 		try {
 			const command = new HeadObjectCommand({
 				Bucket: this.bucket,
@@ -406,35 +206,27 @@ var S3FilesApi = class {
 			const response = await this.client.send(command);
 			return {
 				kind: "file",
-				name: basename(normalized),
-				path: normalized,
 				size: response.ContentLength ?? 0,
-				lastModified: response.LastModified?.getTime() ?? 0,
-				type: response.ContentType
+				lastModified: response.LastModified?.getTime() ?? 0
 			};
 		} catch (error) {
 			const err = error;
 			if (err.name !== "NotFound" && err.$metadata?.httpStatusCode !== 404) throw error;
 		}
-		const prefix = key ? key + "/" : "";
+		const prefix = key ? `${key}/` : "";
 		const listCommand = new ListObjectsV2Command({
 			Bucket: this.bucket,
 			Prefix: prefix,
 			MaxKeys: 1
 		});
 		const listResponse = await this.client.send(listCommand);
-		if (listResponse.Contents && listResponse.Contents.length > 0 || listResponse.CommonPrefixes && listResponse.CommonPrefixes.length > 0) return {
-			kind: "directory",
-			name: basename(normalized),
-			path: normalized,
-			lastModified: 0
-		};
+		if (listResponse.Contents && listResponse.Contents.length > 0 || listResponse.CommonPrefixes && listResponse.CommonPrefixes.length > 0) return { kind: "directory" };
 	}
-	/**
-	* Deletes an object or all objects under a prefix (directory).
-	*/
-	async remove(file) {
-		const key = this.resolveKey(file);
+	async exists(path) {
+		return await this.stats(path) !== void 0;
+	}
+	async remove(path) {
+		const key = this.resolveKey(path);
 		try {
 			const headCommand = new HeadObjectCommand({
 				Bucket: this.bucket,
@@ -451,7 +243,7 @@ var S3FilesApi = class {
 			const err = error;
 			if (err.name !== "NotFound" && err.$metadata?.httpStatusCode !== 404) throw error;
 		}
-		const prefix = key ? key + "/" : "";
+		const prefix = key ? `${key}/` : "";
 		const keysToDelete = [];
 		let continuationToken;
 		do {
@@ -476,48 +268,16 @@ var S3FilesApi = class {
 		}
 		return true;
 	}
-	/**
-	* Opens an S3 object for random access.
-	* Creates the object if it doesn't exist.
-	*/
-	async open(file) {
-		const key = this.resolveKey(file);
-		let size = 0;
-		try {
-			const command = new HeadObjectCommand({
-				Bucket: this.bucket,
-				Key: key
-			});
-			size = (await this.client.send(command)).ContentLength ?? 0;
-		} catch (error) {
-			const err = error;
-			if (err.name !== "NotFound" && err.$metadata?.httpStatusCode !== 404) throw error;
-		}
-		return new S3FileHandle({
-			client: this.client,
-			bucket: this.bucket,
-			key,
-			size,
-			multipartPartSize: this.multipartPartSize
-		});
-	}
-	/**
-	* Moves an object using Copy + Delete.
-	*/
 	async move(source, target) {
 		if (!await this.copy(source, target)) return false;
 		return this.remove(source);
 	}
-	/**
-	* Copies an object or directory using S3 CopyObject.
-	*/
-	async copy(source, target, options = {}) {
+	async copy(source, target) {
 		const sourceKey = this.resolveKey(source);
 		const targetKey = this.resolveKey(target);
-		const { recursive = true } = options;
-		const sourceInfo = await this.stats(source);
-		if (!sourceInfo) return false;
-		if (sourceInfo.kind === "file") {
+		const sourceStats = await this.stats(source);
+		if (!sourceStats) return false;
+		if (sourceStats.kind === "file") {
 			const command = new CopyObjectCommand({
 				Bucket: this.bucket,
 				Key: targetKey,
@@ -526,9 +286,8 @@ var S3FilesApi = class {
 			await this.client.send(command);
 			return true;
 		}
-		if (!recursive) return false;
-		const sourcePrefix = sourceKey + "/";
-		const targetPrefix = targetKey + "/";
+		const sourcePrefix = `${sourceKey}/`;
+		const targetPrefix = `${targetKey}/`;
 		let continuationToken;
 		let copied = false;
 		do {
@@ -553,26 +312,6 @@ var S3FilesApi = class {
 		} while (continuationToken);
 		return copied;
 	}
-	/**
-	* Creates a directory marker in S3.
-	*
-	* S3 doesn't have real directories, but some tools expect
-	* a zero-byte object with trailing slash as a directory marker.
-	* However, for our purposes we don't actually need to create markers
-	* since directories are implied by files within them.
-	*/
-	async mkdir(file) {
-		const key = this.resolveKey(file);
-		const dirKey = key.endsWith("/") ? key : key + "/";
-		const command = new PutObjectCommand({
-			Bucket: this.bucket,
-			Key: dirKey,
-			Body: new Uint8Array(0),
-			ContentLength: 0
-		});
-		await this.client.send(command);
-	}
 };
-
 //#endregion
-export { S3FileHandle, S3FilesApi };
+export { S3FilesApi };