@fragno-dev/upload 0.1.1

package/dist/node/storage/r2.d.ts

@@ -0,0 +1,103 @@
+import { FileKeyEncoded, FileKeyParts } from "../keys.js";
+import { StorageAdapterCapabilities, StorageAdapterRecommendations, UploadChecksum } from "./types.js";
+import { S3CompatibleStorageAdapterOptions } from "./s3.js";
+
+//#region src/storage/r2.d.ts
+type R2StorageAdapterOptions = Omit<S3CompatibleStorageAdapterOptions, "maxMetadataBytes"> & {
+  maxMetadataBytes?: number;
+};
+declare function createR2StorageAdapter(options: R2StorageAdapterOptions): {
+  name: string;
+  limits: {
+    maxMetadataBytes: number;
+    maxSingleUploadBytes?: number;
+    maxMultipartUploadBytes?: number;
+    minMultipartPartSizeBytes?: number;
+    maxMultipartPartSizeBytes?: number;
+    maxMultipartParts?: number;
+    maxStorageKeyLengthBytes?: number;
+  };
+  capabilities: StorageAdapterCapabilities;
+  recommendations?: StorageAdapterRecommendations;
+  resolveStorageKey(input: {
+    fileKey: FileKeyEncoded;
+    fileKeyParts: FileKeyParts;
+  }): string;
+  initUpload(input: {
+    fileKey: FileKeyEncoded;
+    fileKeyParts: FileKeyParts;
+    sizeBytes: bigint;
+    contentType: string;
+    checksum?: UploadChecksum | null;
+    metadata?: Record<string, unknown> | null;
+  }): Promise<{
+    strategy: "direct-single" | "direct-multipart" | "proxy";
+    storageKey: string;
+    storageUploadId?: string;
+    partSizeBytes?: number;
+    expiresAt: Date;
+    uploadUrl?: string;
+    uploadHeaders?: Record<string, string>;
+  }>;
+  getPartUploadUrls?(input: {
+    storageKey: string;
+    storageUploadId: string;
+    partNumbers: number[];
+    partSizeBytes: number;
+  }): Promise<{
+    partNumber: number;
+    url: string;
+    headers?: Record<string, string>;
+  }[]>;
+  completeMultipartUpload?(input: {
+    storageKey: string;
+    storageUploadId: string;
+    parts: {
+      partNumber: number;
+      etag: string;
+    }[];
+  }): Promise<{
+    etag?: string;
+  }>;
+  abortMultipartUpload?(input: {
+    storageKey: string;
+    storageUploadId: string;
+  }): Promise<void>;
+  writeStream?(input: {
+    storageKey: string;
+    body: ReadableStream<Uint8Array>;
+    contentType?: string | null;
+    sizeBytes?: bigint | null;
+  }): Promise<{
+    etag?: string;
+    sizeBytes?: bigint;
+  }>;
+  finalizeUpload?(input: {
+    storageKey: string;
+    expectedSizeBytes: bigint;
+    checksum?: UploadChecksum | null;
+  }): Promise<{
+    sizeBytes?: bigint;
+    etag?: string;
+  }>;
+  deleteObject(input: {
+    storageKey: string;
+  }): Promise<void>;
+  getDownloadUrl?(input: {
+    storageKey: string;
+    expiresInSeconds: number;
+    contentDisposition?: string;
+    contentType?: string;
+  }): Promise<{
+    url: string;
+    headers?: Record<string, string>;
+    expiresAt: Date;
+  }>;
+  getDownloadStream?(input: {
+    storageKey: string;
+  }): Promise<Response>;
+};
+//# sourceMappingURL=r2.d.ts.map
+//#endregion
+export { R2StorageAdapterOptions, createR2StorageAdapter };
+//# sourceMappingURL=r2.d.ts.map

package/dist/node/storage/r2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r2.d.ts","names":[],"sources":["../../../src/storage/r2.ts"],"sourcesContent":[],"mappings":";;;;;KAIY,uBAAA,GAA0B,KACpC;;;iBAMc,sBAAA,UAAgC;EAPpC,IAAA,EAAA,MAAA;EAAuB,MAAA,EAAA;IACjC,gBAAA,EAAA,MAAA;IADoC,oBAAA,CAAA,EAAA,MAAA;IAAI,uBAAA,CAAA,EAAA,MAAA;IAO1B,yBAAsB,CAAA,EAAA,MAAA;IAAA,yBAAA,CAAA,EAAA,MAAA;IAAU,iBAAA,CAAA,EAAA,MAAA;IAAuB,wBAAA,CAAA,EAAA,MAAA;;gBAAA;;;;;MAgBwvB,MAAA;;IAAiQ,OAAA,gBAAA;;IAAsR,SAAA,EAAA,MAAA;;;eAAvhB;;;;;;;IAAunD,SAAA,CAAA,EAAA,MAAA;oBAAt3C;;;;;;;;;;cAAsR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAgmC"}

package/dist/node/storage/r2.js

@@ -0,0 +1,23 @@
+import { createS3CompatibleStorageAdapter } from "./s3.js";
+
+//#region src/storage/r2.ts
+const DEFAULT_MAX_METADATA_BYTES = 8192;
+function createR2StorageAdapter(options) {
+	const maxMetadataBytes = options.maxMetadataBytes ?? DEFAULT_MAX_METADATA_BYTES;
+	const adapter = createS3CompatibleStorageAdapter({
+		...options,
+		maxMetadataBytes
+	});
+	return {
+		...adapter,
+		name: "r2",
+		limits: {
+			...adapter.limits,
+			maxMetadataBytes
+		}
+	};
+}
+
+//#endregion
+export { createR2StorageAdapter };
+//# sourceMappingURL=r2.js.map

package/dist/node/storage/r2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"r2.js","names":[],"sources":["../../../src/storage/r2.ts"],"sourcesContent":["import { createS3CompatibleStorageAdapter, type S3CompatibleStorageAdapterOptions } from \"./s3\";\n\nconst DEFAULT_MAX_METADATA_BYTES = 8_192;\n\nexport type R2StorageAdapterOptions = Omit<\n  S3CompatibleStorageAdapterOptions,\n  \"maxMetadataBytes\"\n> & {\n  maxMetadataBytes?: number;\n};\n\nexport function createR2StorageAdapter(options: R2StorageAdapterOptions) {\n  const maxMetadataBytes = options.maxMetadataBytes ?? DEFAULT_MAX_METADATA_BYTES;\n  const adapter = createS3CompatibleStorageAdapter({\n    ...options,\n    maxMetadataBytes,\n  });\n\n  return {\n    ...adapter,\n    name: \"r2\",\n    limits: {\n      ...adapter.limits,\n      maxMetadataBytes,\n    },\n  };\n}\n"],"mappings":";;;AAEA,MAAM,6BAA6B;AASnC,SAAgB,uBAAuB,SAAkC;CACvE,MAAM,mBAAmB,QAAQ,oBAAoB;CACrD,MAAM,UAAU,iCAAiC;EAC/C,GAAG;EACH;EACD,CAAC;AAEF,QAAO;EACL,GAAG;EACH,MAAM;EACN,QAAQ;GACN,GAAG,QAAQ;GACX;GACD;EACF"}

package/dist/node/storage/s3.d.ts

@@ -0,0 +1,44 @@
+import { StorageAdapter } from "./types.js";
+
+//#region src/storage/s3.d.ts
+type S3SignerInput = {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  body?: string | Uint8Array | null;
+  expiresInSeconds?: number;
+};
+type S3Signer = {
+  sign: (input: S3SignerInput) => Promise<{
+    url: string;
+    headers: Record<string, string>;
+  }>;
+  presign: (input: S3SignerInput) => Promise<{
+    url: string;
+    headers?: Record<string, string>;
+  }>;
+};
+type S3CompatibleStorageAdapterOptions = {
+  bucket: string;
+  endpoint: string;
+  signer: S3Signer;
+  storageKeyPrefix?: string;
+  pathStyle?: boolean;
+  uploadExpiresInSeconds?: number;
+  signedUrlExpiresInSeconds?: number;
+  directUploadThresholdBytes?: number;
+  multipartThresholdBytes?: number;
+  multipartPartSizeBytes?: number;
+  maxSingleUploadBytes?: number;
+  maxMultipartUploadBytes?: number;
+  minMultipartPartSizeBytes?: number;
+  maxMultipartPartSizeBytes?: number;
+  maxMultipartParts?: number;
+  maxStorageKeyLengthBytes?: number;
+  maxMetadataBytes?: number;
+};
+declare function createS3CompatibleStorageAdapter(options: S3CompatibleStorageAdapterOptions): StorageAdapter;
+//# sourceMappingURL=s3.d.ts.map
+//#endregion
+export { S3CompatibleStorageAdapterOptions, S3Signer, S3SignerInput, createS3CompatibleStorageAdapter };
+//# sourceMappingURL=s3.d.ts.map

package/dist/node/storage/s3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3.d.ts","names":[],"sources":["../../../src/storage/s3.ts"],"sourcesContent":[],"mappings":";;;KAmBY,aAAA;;EAAA,GAAA,EAAA,MAAA;EAAa,OAAA,CAAA,EAGb,MAHa,CAAA,MAAA,EAAA,MAAA,CAAA;MAGb,CAAA,EAAA,MAAA,GACM,UADN,GAAA,IAAA;kBACM,CAAA,EAAA,MAAA;CAAU;AAIhB,KAAA,QAAA,GAAQ;EAAA,IAAA,EAAA,CAAA,KAAA,EACJ,aADI,EAAA,GACc,OADd,CAAA;IACJ,GAAA,EAAA,MAAA;IAAkD,OAAA,EAAA,MAAA,CAAA,MAAA,EAAA,MAAA,CAAA;;SAC/C,EAAA,CAAA,KAAA,EAAA,aAAA,EAAA,GAAkB,OAAlB,CAAA;IAAmD,GAAA,EAAA,MAAA;IAAjC,OAAA,CAAA,EAAiC,MAAjC,CAAA,MAAA,EAAA,MAAA,CAAA;EAAO,CAAA,CAAA;AAG5C,CAAA;AAqRgB,KArRJ,iCAAA,GAqRoC;EAAA,MAAA,EAAA,MAAA;UACrC,EAAA,MAAA;QACR,EApRO,QAoRP;EAAc,gBAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;iBAFD,gCAAA,UACL,oCACR"}

package/dist/node/storage/s3.js

@@ -0,0 +1,398 @@
+import { encodeFileKey } from "../keys.js";
+import { createHash } from "node:crypto";
+
+//#region src/storage/s3.ts
+const BYTES_IN_MIB = 1024 * 1024;
+const BYTES_IN_GIB = 1024 * BYTES_IN_MIB;
+const BYTES_IN_TIB = 1024 * BYTES_IN_GIB;
+const DEFAULT_MAX_SINGLE_UPLOAD_BYTES = 5 * BYTES_IN_GIB;
+const DEFAULT_MAX_MULTIPART_UPLOAD_BYTES = 5 * BYTES_IN_TIB;
+const DEFAULT_MIN_MULTIPART_PART_SIZE_BYTES = 5 * BYTES_IN_MIB;
+const DEFAULT_MAX_MULTIPART_PART_SIZE_BYTES = 5 * BYTES_IN_GIB;
+const DEFAULT_MAX_MULTIPART_PARTS = 1e4;
+const DEFAULT_MAX_STORAGE_KEY_LENGTH_BYTES = 1024;
+const DEFAULT_UPLOAD_EXPIRES_IN_SECONDS = 3600;
+const DEFAULT_SIGNED_URL_EXPIRES_IN_SECONDS = 3600;
+const DEFAULT_MULTIPART_PART_SIZE_BYTES = 8 * BYTES_IN_MIB;
+const MAX_PRESIGNED_EXPIRES_IN_SECONDS = 3600 * 24 * 7;
+const normalizePrefix = (prefix) => {
+	if (!prefix) return "";
+	const segments = prefix.split("/").filter(Boolean);
+	for (const segment of segments) if (segment === "." || segment === "..") throw new Error("Storage key prefix cannot include '.' or '..' segments");
+	return segments.join("/");
+};
+const resolveStorageKeyFromParts = (input) => {
+	const encoded = input.fileKeyParts.length > 0 ? encodeFileKey(input.fileKeyParts) : input.fileKey;
+	return encoded.length > 0 ? encoded.split(".").join("/") : "";
+};
+const encodePathSegments = (value) => value.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+const joinPathSegments = (...segments) => {
+	return segments.filter(Boolean).map((segment) => segment.replace(/^\/+|\/+$/g, "")).join("/");
+};
+const parseHex = (value, expectedBytes) => {
+	const trimmed = value.trim();
+	if (!/^[0-9a-f]+$/i.test(trimmed) || trimmed.length !== expectedBytes * 2) return null;
+	return Buffer.from(trimmed, "hex");
+};
+const parseBase64 = (value, expectedBytes) => {
+	const trimmed = value.trim();
+	if (!/^[A-Za-z0-9+/=]+$/.test(trimmed)) return null;
+	const buf = Buffer.from(trimmed, "base64");
+	if (buf.length !== expectedBytes) return null;
+	return buf;
+};
+const normalizeChecksum = (checksum) => {
+	if (!checksum) return null;
+	const expectedBytes = checksum.algo === "md5" ? 16 : 32;
+	const raw = checksum.value ?? "";
+	const buf = parseHex(raw, expectedBytes) ?? parseBase64(raw, expectedBytes);
+	if (!buf) throw new Error("INVALID_CHECKSUM");
+	return {
+		algo: checksum.algo,
+		hex: buf.toString("hex"),
+		base64: buf.toString("base64")
+	};
+};
+const resolveChecksumHeaders = (checksum) => {
+	const normalized = normalizeChecksum(checksum);
+	if (!normalized) return {};
+	if (normalized.algo === "md5") return { "Content-MD5": normalized.base64 };
+	return { "x-amz-checksum-sha256": normalized.base64 };
+};
+const normalizeEtag = (etag) => {
+	if (!etag) return null;
+	const trimmed = etag.trim().replace(/^W\//, "").replace(/^"|"$/g, "");
+	if (!/^[0-9a-f]{32}$/i.test(trimmed)) return null;
+	return trimmed.toLowerCase();
+};
+const computeChecksumFromResponse = async (response, algo) => {
+	if (!response.body) throw new Error("STORAGE_ERROR");
+	const hash = createHash(algo);
+	const reader = response.body.getReader();
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		if (value) hash.update(Buffer.from(value));
+	}
+	return hash.digest("hex");
+};
+const parseContentLength = (value) => {
+	if (!value) return null;
+	if (!/^\d+$/.test(value)) return null;
+	return BigInt(value);
+};
+const getHeaderValue = (headers, name) => {
+	const direct = headers.get(name);
+	if (direct !== null) return direct;
+	const target = name.toLowerCase();
+	for (const [key, value] of headers.entries()) if (key.toLowerCase() === target) return value;
+	return null;
+};
+const buildObjectUrl = (input) => {
+	const url = new URL(input.endpoint);
+	const encodedKey = encodePathSegments(input.storageKey);
+	const basePath = url.pathname === "/" ? "" : url.pathname.replace(/\/+$/g, "");
+	if (input.pathStyle) {
+		const path$1 = joinPathSegments(basePath, input.bucket, encodedKey);
+		url.pathname = path$1 ? `/${path$1}` : "/";
+		return url;
+	}
+	url.hostname = `${input.bucket}.${url.hostname}`;
+	const path = joinPathSegments(basePath, encodedKey);
+	url.pathname = path ? `/${path}` : "/";
+	return url;
+};
+const assertExpiresInSeconds = (value) => {
+	if (!Number.isFinite(value) || value <= 0) throw new Error("Expiration must be a positive number of seconds");
+	if (value > MAX_PRESIGNED_EXPIRES_IN_SECONDS) throw new Error("Expiration exceeds SigV4 maximum of 7 days");
+};
+const resolveMetadataSize = (metadata) => {
+	if (!metadata) return 0;
+	const serialized = JSON.stringify(metadata);
+	return Buffer.byteLength(serialized, "utf8");
+};
+const parseUploadId = (payload) => {
+	const match = payload.match(/<UploadId>([^<]+)<\/UploadId>/);
+	if (!match) return null;
+	return match[1];
+};
+const escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+const buildCompleteMultipartBody = (parts) => {
+	return `<?xml version="1.0" encoding="UTF-8"?><CompleteMultipartUpload>${[...parts].sort((a, b) => a.partNumber - b.partNumber).map((part) => `<Part><PartNumber>${part.partNumber}</PartNumber><ETag>${escapeXml(part.etag)}</ETag></Part>`).join("")}</CompleteMultipartUpload>`;
+};
+const resolveMultipartPartSize = (input) => {
+	let partSize = input.desiredPartSizeBytes;
+	if (partSize < input.minPartSizeBytes) partSize = input.minPartSizeBytes;
+	if (partSize > input.maxPartSizeBytes) throw new Error("Multipart part size exceeds maximum allowed size");
+	const sizeNumber = Number(input.sizeBytes);
+	const minimumPartSizeForLimit = Math.ceil(sizeNumber / input.maxParts);
+	if (minimumPartSizeForLimit > partSize) partSize = minimumPartSizeForLimit;
+	if (partSize < input.minPartSizeBytes) partSize = input.minPartSizeBytes;
+	if (partSize > input.maxPartSizeBytes) throw new Error("Multipart part size exceeds maximum allowed size");
+	if (Math.ceil(sizeNumber / partSize) > input.maxParts) throw new Error("Multipart upload exceeds maximum number of parts");
+	return partSize;
+};
+function createS3CompatibleStorageAdapter(options) {
+	const storageKeyPrefix = normalizePrefix(options.storageKeyPrefix ?? "");
+	const pathStyle = options.pathStyle ?? false;
+	const maxStorageKeyLengthBytes = options.maxStorageKeyLengthBytes ?? DEFAULT_MAX_STORAGE_KEY_LENGTH_BYTES;
+	const maxSingleUploadBytes = options.maxSingleUploadBytes ?? DEFAULT_MAX_SINGLE_UPLOAD_BYTES;
+	const maxMultipartUploadBytes = options.maxMultipartUploadBytes ?? DEFAULT_MAX_MULTIPART_UPLOAD_BYTES;
+	const minMultipartPartSizeBytes = options.minMultipartPartSizeBytes ?? DEFAULT_MIN_MULTIPART_PART_SIZE_BYTES;
+	const maxMultipartPartSizeBytes = options.maxMultipartPartSizeBytes ?? DEFAULT_MAX_MULTIPART_PART_SIZE_BYTES;
+	const maxMultipartParts = options.maxMultipartParts ?? DEFAULT_MAX_MULTIPART_PARTS;
+	const uploadExpiresInSeconds = options.uploadExpiresInSeconds ?? DEFAULT_UPLOAD_EXPIRES_IN_SECONDS;
+	const signedUrlExpiresInSeconds = options.signedUrlExpiresInSeconds ?? DEFAULT_SIGNED_URL_EXPIRES_IN_SECONDS;
+	const directUploadThresholdBytes = options.directUploadThresholdBytes ?? maxSingleUploadBytes;
+	const multipartThresholdBytes = options.multipartThresholdBytes ?? maxSingleUploadBytes;
+	const multipartPartSizeBytes = options.multipartPartSizeBytes ?? DEFAULT_MULTIPART_PART_SIZE_BYTES;
+	assertExpiresInSeconds(uploadExpiresInSeconds);
+	assertExpiresInSeconds(signedUrlExpiresInSeconds);
+	const resolveStorageKey = (input) => {
+		const storageKey = [storageKeyPrefix, resolveStorageKeyFromParts(input)].filter(Boolean).join("/");
+		if (storageKey.length === 0) throw new Error("Storage key cannot be empty");
+		if (Buffer.byteLength(storageKey, "utf8") > maxStorageKeyLengthBytes) throw new Error("Storage key exceeds maximum length");
+		return storageKey;
+	};
+	const buildUrl = (storageKey, queryParams = {}) => {
+		const url = buildObjectUrl({
+			endpoint: options.endpoint,
+			bucket: options.bucket,
+			storageKey,
+			pathStyle
+		});
+		for (const [key, value] of Object.entries(queryParams)) {
+			if (value === void 0) continue;
+			url.searchParams.set(key, value);
+		}
+		return url;
+	};
+	const validateMetadata = (metadata) => {
+		if (!metadata) return;
+		if (options.maxMetadataBytes === void 0) return;
+		if (resolveMetadataSize(metadata) > options.maxMetadataBytes) throw new Error("Metadata exceeds maximum size");
+	};
+	return {
+		name: "s3",
+		capabilities: {
+			directUpload: true,
+			multipartUpload: true,
+			signedDownload: true,
+			proxyUpload: false
+		},
+		limits: {
+			maxSingleUploadBytes,
+			maxMultipartUploadBytes,
+			minMultipartPartSizeBytes,
+			maxMultipartPartSizeBytes,
+			maxMultipartParts,
+			maxStorageKeyLengthBytes,
+			maxMetadataBytes: options.maxMetadataBytes
+		},
+		recommendations: {
+			uploadExpiresInSeconds,
+			signedUrlExpiresInSeconds,
+			directUploadThresholdBytes,
+			multipartThresholdBytes,
+			multipartPartSizeBytes
+		},
+		resolveStorageKey,
+		initUpload: async ({ fileKey, fileKeyParts, sizeBytes, contentType, metadata, checksum }) => {
+			validateMetadata(metadata);
+			const storageKey = resolveStorageKey({
+				fileKey,
+				fileKeyParts
+			});
+			const expiresAt = new Date(Date.now() + uploadExpiresInSeconds * 1e3);
+			const sizeNumber = Number(sizeBytes);
+			if (Number.isNaN(sizeNumber) || sizeNumber < 0) throw new Error("Upload size must be a non-negative number");
+			const canMultipart = sizeNumber <= maxMultipartUploadBytes;
+			const canSingle = sizeNumber <= maxSingleUploadBytes;
+			if (!canMultipart) throw new Error("Upload exceeds maximum multipart size");
+			if (sizeNumber >= multipartThresholdBytes || !(canSingle && sizeNumber <= directUploadThresholdBytes)) {
+				if (!canMultipart) throw new Error("Upload exceeds maximum multipart size");
+				const partSizeBytes = resolveMultipartPartSize({
+					sizeBytes,
+					desiredPartSizeBytes: multipartPartSizeBytes,
+					minPartSizeBytes: minMultipartPartSizeBytes,
+					maxPartSizeBytes: maxMultipartPartSizeBytes,
+					maxParts: maxMultipartParts
+				});
+				const createUrl = buildUrl(storageKey, { uploads: "" });
+				const signed$1 = await options.signer.sign({
+					method: "POST",
+					url: createUrl.toString(),
+					headers: { "Content-Type": contentType }
+				});
+				const response = await fetch(signed$1.url, {
+					method: "POST",
+					headers: signed$1.headers
+				});
+				if (!response.ok) throw new Error(`Failed to create multipart upload (${response.status})`);
+				const uploadId = parseUploadId(await response.text());
+				if (!uploadId) throw new Error("Failed to parse multipart upload id");
+				return {
+					strategy: "direct-multipart",
+					storageKey,
+					storageUploadId: uploadId,
+					partSizeBytes,
+					expiresAt
+				};
+			}
+			if (!canSingle) throw new Error("Upload exceeds maximum single upload size");
+			const uploadUrl = buildUrl(storageKey);
+			const checksumHeaders = resolveChecksumHeaders(checksum);
+			const signed = await options.signer.presign({
+				method: "PUT",
+				url: uploadUrl.toString(),
+				headers: {
+					"Content-Type": contentType,
+					...checksumHeaders
+				},
+				expiresInSeconds: uploadExpiresInSeconds
+			});
+			return {
+				strategy: "direct-single",
+				storageKey,
+				expiresAt,
+				uploadUrl: signed.url,
+				uploadHeaders: signed.headers
+			};
+		},
+		getPartUploadUrls: async ({ storageKey, storageUploadId, partNumbers }) => {
+			for (const partNumber of partNumbers) if (partNumber < 1 || partNumber > maxMultipartParts) throw new Error("INVALID_REQUEST");
+			return await Promise.all(partNumbers.map(async (partNumber) => {
+				const url = buildUrl(storageKey, {
+					partNumber: String(partNumber),
+					uploadId: storageUploadId
+				});
+				const signed = await options.signer.presign({
+					method: "PUT",
+					url: url.toString(),
+					expiresInSeconds: uploadExpiresInSeconds
+				});
+				return {
+					partNumber,
+					url: signed.url,
+					headers: signed.headers
+				};
+			}));
+		},
+		completeMultipartUpload: async ({ storageKey, storageUploadId, parts }) => {
+			const url = buildUrl(storageKey, { uploadId: storageUploadId });
+			const body = buildCompleteMultipartBody(parts);
+			const signed = await options.signer.sign({
+				method: "POST",
+				url: url.toString(),
+				headers: { "Content-Type": "application/xml" },
+				body
+			});
+			const response = await fetch(signed.url, {
+				method: "POST",
+				headers: signed.headers,
+				body
+			});
+			if (!response.ok) throw new Error(`Failed to complete multipart upload (${response.status})`);
+			return { etag: response.headers.get("ETag") ?? void 0 };
+		},
+		abortMultipartUpload: async ({ storageKey, storageUploadId }) => {
+			const url = buildUrl(storageKey, { uploadId: storageUploadId });
+			const signed = await options.signer.sign({
+				method: "DELETE",
+				url: url.toString()
+			});
+			const response = await fetch(signed.url, {
+				method: "DELETE",
+				headers: signed.headers
+			});
+			if (!response.ok) throw new Error(`Failed to abort multipart upload (${response.status})`);
+		},
+		finalizeUpload: async ({ storageKey, expectedSizeBytes, checksum }) => {
+			const url = buildUrl(storageKey);
+			const signed = await options.signer.sign({
+				method: "HEAD",
+				url: url.toString()
+			});
+			const response = await fetch(signed.url, {
+				method: "HEAD",
+				headers: signed.headers
+			});
+			if (!response.ok) throw new Error("STORAGE_ERROR");
+			const sizeBytes = parseContentLength(getHeaderValue(response.headers, "content-length"));
+			if (sizeBytes === null) throw new Error("STORAGE_ERROR");
+			if (sizeBytes !== expectedSizeBytes) throw new Error("INVALID_CHECKSUM");
+			const normalized = normalizeChecksum(checksum);
+			if (normalized) if (normalized.algo === "md5") {
+				const etag = normalizeEtag(getHeaderValue(response.headers, "etag"));
+				if (etag) {
+					if (etag !== normalized.hex) throw new Error("INVALID_CHECKSUM");
+				} else {
+					const signedGet = await options.signer.sign({
+						method: "GET",
+						url: buildUrl(storageKey).toString()
+					});
+					const getResponse = await fetch(signedGet.url, {
+						method: "GET",
+						headers: signedGet.headers
+					});
+					if (!getResponse.ok) throw new Error("STORAGE_ERROR");
+					if (await computeChecksumFromResponse(getResponse, "md5") !== normalized.hex) throw new Error("INVALID_CHECKSUM");
+				}
+			} else {
+				const checksumHeader = getHeaderValue(response.headers, "x-amz-checksum-sha256");
+				if (checksumHeader) {
+					const remote = parseBase64(checksumHeader, 32);
+					if (!remote || remote.toString("base64") !== normalized.base64) throw new Error("INVALID_CHECKSUM");
+				} else {
+					const signedGet = await options.signer.sign({
+						method: "GET",
+						url: buildUrl(storageKey).toString()
+					});
+					const getResponse = await fetch(signedGet.url, {
+						method: "GET",
+						headers: signedGet.headers
+					});
+					if (!getResponse.ok) throw new Error("STORAGE_ERROR");
+					if (await computeChecksumFromResponse(getResponse, "sha256") !== normalized.hex) throw new Error("INVALID_CHECKSUM");
+				}
+			}
+			return {
+				sizeBytes,
+				etag: getHeaderValue(response.headers, "etag") ?? void 0
+			};
+		},
+		deleteObject: async ({ storageKey }) => {
+			const url = buildUrl(storageKey);
+			const signed = await options.signer.sign({
+				method: "DELETE",
+				url: url.toString()
+			});
+			const response = await fetch(signed.url, {
+				method: "DELETE",
+				headers: signed.headers
+			});
+			if (!response.ok) throw new Error(`Failed to delete object (${response.status})`);
+		},
+		getDownloadUrl: async ({ storageKey, expiresInSeconds, contentDisposition, contentType }) => {
+			assertExpiresInSeconds(expiresInSeconds);
+			const url = buildUrl(storageKey, {
+				"response-content-disposition": contentDisposition,
+				"response-content-type": contentType
+			});
+			const signed = await options.signer.presign({
+				method: "GET",
+				url: url.toString(),
+				expiresInSeconds
+			});
+			return {
+				url: signed.url,
+				headers: signed.headers,
+				expiresAt: new Date(Date.now() + expiresInSeconds * 1e3)
+			};
+		}
+	};
+}
+
+//#endregion
+export { createS3CompatibleStorageAdapter };
+//# sourceMappingURL=s3.js.map

package/dist/node/storage/s3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3.js","names":["path","signed"],"sources":["../../../src/storage/s3.ts"],"sourcesContent":["import { encodeFileKey, type FileKeyEncoded, type FileKeyParts } from \"../keys\";\nimport { createHash } from \"node:crypto\";\nimport type { StorageAdapter, UploadChecksum } from \"./types\";\n\nconst BYTES_IN_MIB = 1024 * 1024;\nconst BYTES_IN_GIB = 1024 * BYTES_IN_MIB;\nconst BYTES_IN_TIB = 1024 * BYTES_IN_GIB;\n\nconst DEFAULT_MAX_SINGLE_UPLOAD_BYTES = 5 * BYTES_IN_GIB;\nconst DEFAULT_MAX_MULTIPART_UPLOAD_BYTES = 5 * BYTES_IN_TIB;\nconst DEFAULT_MIN_MULTIPART_PART_SIZE_BYTES = 5 * BYTES_IN_MIB;\nconst DEFAULT_MAX_MULTIPART_PART_SIZE_BYTES = 5 * BYTES_IN_GIB;\nconst DEFAULT_MAX_MULTIPART_PARTS = 10_000;\nconst DEFAULT_MAX_STORAGE_KEY_LENGTH_BYTES = 1024;\nconst DEFAULT_UPLOAD_EXPIRES_IN_SECONDS = 60 * 60;\nconst DEFAULT_SIGNED_URL_EXPIRES_IN_SECONDS = 60 * 60;\nconst DEFAULT_MULTIPART_PART_SIZE_BYTES = 8 * BYTES_IN_MIB;\nconst MAX_PRESIGNED_EXPIRES_IN_SECONDS = 60 * 60 * 24 * 7;\n\nexport type S3SignerInput = {\n  method: string;\n  url: string;\n  headers?: Record<string, string>;\n  body?: string | Uint8Array | null;\n  expiresInSeconds?: number;\n};\n\nexport type S3Signer = {\n  sign: (input: S3SignerInput) => Promise<{ url: string; headers: Record<string, string> }>;\n  presign: (input: S3SignerInput) => Promise<{ url: string; headers?: Record<string, string> }>;\n};\n\nexport type S3CompatibleStorageAdapterOptions = {\n  bucket: string;\n  endpoint: string;\n  signer: S3Signer;\n  storageKeyPrefix?: string;\n  pathStyle?: boolean;\n  uploadExpiresInSeconds?: number;\n  signedUrlExpiresInSeconds?: number;\n  directUploadThresholdBytes?: number;\n  multipartThresholdBytes?: number;\n  multipartPartSizeBytes?: number;\n  maxSingleUploadBytes?: number;\n  maxMultipartUploadBytes?: number;\n  minMultipartPartSizeBytes?: number;\n  maxMultipartPartSizeBytes?: number;\n  maxMultipartParts?: number;\n  maxStorageKeyLengthBytes?: number;\n  maxMetadataBytes?: number;\n};\n\nconst normalizePrefix = (prefix: string): string => {\n  if (!prefix) {\n    return \"\";\n  }\n\n  const segments = prefix.split(\"/\").filter(Boolean);\n  for (const segment of segments) {\n    if (segment === \".\" || segment === \"..\") {\n      throw new Error(\"Storage key prefix cannot include '.' or '..' segments\");\n    }\n  }\n\n  return segments.join(\"/\");\n};\n\nconst resolveStorageKeyFromParts = (input: {\n  fileKey: FileKeyEncoded;\n  fileKeyParts: FileKeyParts;\n}): string => {\n  const encoded = input.fileKeyParts.length > 0 ? encodeFileKey(input.fileKeyParts) : input.fileKey;\n  return encoded.length > 0 ? encoded.split(\".\").join(\"/\") : \"\";\n};\n\nconst encodePathSegments = (value: string) =>\n  value\n    .split(\"/\")\n    .map((segment) => encodeURIComponent(segment))\n    .join(\"/\");\n\nconst joinPathSegments = (...segments: (string | undefined)[]) => {\n  const trimmed = segments.filter(Boolean).map((segment) => segment!.replace(/^\\/+|\\/+$/g, \"\"));\n  return trimmed.join(\"/\");\n};\n\nconst parseHex = (value: string, expectedBytes: number) => {\n  const trimmed = value.trim();\n  if (!/^[0-9a-f]+$/i.test(trimmed) || trimmed.length !== expectedBytes * 2) {\n    return null;\n  }\n  return Buffer.from(trimmed, \"hex\");\n};\n\nconst parseBase64 = (value: string, expectedBytes: number) => {\n  const trimmed = value.trim();\n  if (!/^[A-Za-z0-9+/=]+$/.test(trimmed)) {\n    return null;\n  }\n  const buf = Buffer.from(trimmed, \"base64\");\n  if (buf.length !== expectedBytes) {\n    return null;\n  }\n  return buf;\n};\n\nconst normalizeChecksum = (checksum?: UploadChecksum | null) => {\n  if (!checksum) {\n    return null;\n  }\n\n  const expectedBytes = checksum.algo === \"md5\" ? 16 : 32;\n  const raw = checksum.value ?? \"\";\n  const buf = parseHex(raw, expectedBytes) ?? parseBase64(raw, expectedBytes);\n  if (!buf) {\n    throw new Error(\"INVALID_CHECKSUM\");\n  }\n\n  return {\n    algo: checksum.algo,\n    hex: buf.toString(\"hex\"),\n    base64: buf.toString(\"base64\"),\n  };\n};\n\nconst resolveChecksumHeaders = (checksum?: UploadChecksum | null): Record<string, string> => {\n  const normalized = normalizeChecksum(checksum);\n  if (!normalized) {\n    return {};\n  }\n\n  if (normalized.algo === \"md5\") {\n    return { \"Content-MD5\": normalized.base64 };\n  }\n\n  return { \"x-amz-checksum-sha256\": normalized.base64 };\n};\n\nconst normalizeEtag = (etag: string | null) => {\n  if (!etag) {\n    return null;\n  }\n\n  const trimmed = etag.trim().replace(/^W\\//, \"\").replace(/^\"|\"$/g, \"\");\n  if (!/^[0-9a-f]{32}$/i.test(trimmed)) {\n    return null;\n  }\n\n  return trimmed.toLowerCase();\n};\n\nconst computeChecksumFromResponse = async (\n  response: Response,\n  algo: \"md5\" | \"sha256\",\n): Promise<string> => {\n  if (!response.body) {\n    throw new Error(\"STORAGE_ERROR\");\n  }\n\n  const hash = createHash(algo);\n  const reader = response.body.getReader();\n\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) {\n      break;\n    }\n    if (value) {\n      hash.update(Buffer.from(value));\n    }\n  }\n\n  return hash.digest(\"hex\");\n};\n\nconst parseContentLength = (value: string | null) => {\n  if (!value) {\n    return null;\n  }\n  if (!/^\\d+$/.test(value)) {\n    return null;\n  }\n  return BigInt(value);\n};\n\nconst getHeaderValue = (headers: Headers, name: string) => {\n  const direct = headers.get(name);\n  if (direct !== null) {\n    return direct;\n  }\n  const target = name.toLowerCase();\n  for (const [key, value] of headers.entries()) {\n    if (key.toLowerCase() === target) {\n      return value;\n    }\n  }\n  return null;\n};\n\nconst buildObjectUrl = (input: {\n  endpoint: string;\n  bucket: string;\n  storageKey: string;\n  pathStyle: boolean;\n}) => {\n  const url = new URL(input.endpoint);\n  const encodedKey = encodePathSegments(input.storageKey);\n  const basePath = url.pathname === \"/\" ? \"\" : url.pathname.replace(/\\/+$/g, \"\");\n\n  if (input.pathStyle) {\n    const path = joinPathSegments(basePath, input.bucket, encodedKey);\n    url.pathname = path ? `/${path}` : \"/\";\n    return url;\n  }\n\n  url.hostname = `${input.bucket}.${url.hostname}`;\n  const path = joinPathSegments(basePath, encodedKey);\n  url.pathname = path ? `/${path}` : \"/\";\n  return url;\n};\n\nconst assertExpiresInSeconds = (value: number) => {\n  if (!Number.isFinite(value) || value <= 0) {\n    throw new Error(\"Expiration must be a positive number of seconds\");\n  }\n  if (value > MAX_PRESIGNED_EXPIRES_IN_SECONDS) {\n    throw new Error(\"Expiration exceeds SigV4 maximum of 7 days\");\n  }\n};\n\nconst resolveMetadataSize = (metadata?: Record<string, unknown> | null) => {\n  if (!metadata) {\n    return 0;\n  }\n\n  const serialized = JSON.stringify(metadata);\n  return Buffer.byteLength(serialized, \"utf8\");\n};\n\nconst parseUploadId = (payload: string) => {\n  const match = payload.match(/<UploadId>([^<]+)<\\/UploadId>/);\n  if (!match) {\n    return null;\n  }\n\n  return match[1];\n};\n\nconst escapeXml = (value: string) =>\n  value\n    .replace(/&/g, \"&amp;\")\n    .replace(/</g, \"&lt;\")\n    .replace(/>/g, \"&gt;\")\n    .replace(/\"/g, \"&quot;\")\n    .replace(/'/g, \"&apos;\");\n\nconst buildCompleteMultipartBody = (parts: { partNumber: number; etag: string }[]) => {\n  const sorted = [...parts].sort((a, b) => a.partNumber - b.partNumber);\n  const entries = sorted\n    .map(\n      (part) =>\n        `<Part><PartNumber>${part.partNumber}</PartNumber><ETag>${escapeXml(\n          part.etag,\n        )}</ETag></Part>`,\n    )\n    .join(\"\");\n  return `<?xml version=\"1.0\" encoding=\"UTF-8\"?><CompleteMultipartUpload>${entries}</CompleteMultipartUpload>`;\n};\n\nconst resolveMultipartPartSize = (input: {\n  sizeBytes: bigint;\n  desiredPartSizeBytes: number;\n  minPartSizeBytes: number;\n  maxPartSizeBytes: number;\n  maxParts: number;\n}) => {\n  let partSize = input.desiredPartSizeBytes;\n\n  if (partSize < input.minPartSizeBytes) {\n    partSize = input.minPartSizeBytes;\n  }\n\n  if (partSize > input.maxPartSizeBytes) {\n    throw new Error(\"Multipart part size exceeds maximum allowed size\");\n  }\n\n  const sizeNumber = Number(input.sizeBytes);\n  const minimumPartSizeForLimit = Math.ceil(sizeNumber / input.maxParts);\n\n  if (minimumPartSizeForLimit > partSize) {\n    partSize = minimumPartSizeForLimit;\n  }\n\n  if (partSize < input.minPartSizeBytes) {\n    partSize = input.minPartSizeBytes;\n  }\n\n  if (partSize > input.maxPartSizeBytes) {\n    throw new Error(\"Multipart part size exceeds maximum allowed size\");\n  }\n\n  const partCount = Math.ceil(sizeNumber / partSize);\n  if (partCount > input.maxParts) {\n    throw new Error(\"Multipart upload exceeds maximum number of parts\");\n  }\n\n  return partSize;\n};\n\nexport function createS3CompatibleStorageAdapter(\n  options: S3CompatibleStorageAdapterOptions,\n): StorageAdapter {\n  const storageKeyPrefix = normalizePrefix(options.storageKeyPrefix ?? \"\");\n  const pathStyle = options.pathStyle ?? false;\n  const maxStorageKeyLengthBytes =\n    options.maxStorageKeyLengthBytes ?? DEFAULT_MAX_STORAGE_KEY_LENGTH_BYTES;\n  const maxSingleUploadBytes = options.maxSingleUploadBytes ?? DEFAULT_MAX_SINGLE_UPLOAD_BYTES;\n  const maxMultipartUploadBytes =\n    options.maxMultipartUploadBytes ?? DEFAULT_MAX_MULTIPART_UPLOAD_BYTES;\n  const minMultipartPartSizeBytes =\n    options.minMultipartPartSizeBytes ?? DEFAULT_MIN_MULTIPART_PART_SIZE_BYTES;\n  const maxMultipartPartSizeBytes =\n    options.maxMultipartPartSizeBytes ?? DEFAULT_MAX_MULTIPART_PART_SIZE_BYTES;\n  const maxMultipartParts = options.maxMultipartParts ?? DEFAULT_MAX_MULTIPART_PARTS;\n  const uploadExpiresInSeconds =\n    options.uploadExpiresInSeconds ?? DEFAULT_UPLOAD_EXPIRES_IN_SECONDS;\n  const signedUrlExpiresInSeconds =\n    options.signedUrlExpiresInSeconds ?? DEFAULT_SIGNED_URL_EXPIRES_IN_SECONDS;\n  const directUploadThresholdBytes = options.directUploadThresholdBytes ?? maxSingleUploadBytes;\n  const multipartThresholdBytes = options.multipartThresholdBytes ?? maxSingleUploadBytes;\n  const multipartPartSizeBytes =\n    options.multipartPartSizeBytes ?? DEFAULT_MULTIPART_PART_SIZE_BYTES;\n\n  assertExpiresInSeconds(uploadExpiresInSeconds);\n  assertExpiresInSeconds(signedUrlExpiresInSeconds);\n\n  const resolveStorageKey = (input: { fileKey: FileKeyEncoded; fileKeyParts: FileKeyParts }) => {\n    const baseKey = resolveStorageKeyFromParts(input);\n    const storageKey = [storageKeyPrefix, baseKey].filter(Boolean).join(\"/\");\n\n    if (storageKey.length === 0) {\n      throw new Error(\"Storage key cannot be empty\");\n    }\n\n    if (Buffer.byteLength(storageKey, \"utf8\") > maxStorageKeyLengthBytes) {\n      throw new Error(\"Storage key exceeds maximum length\");\n    }\n\n    return storageKey;\n  };\n\n  const buildUrl = (storageKey: string, queryParams: Record<string, string | undefined> = {}) => {\n    const url = buildObjectUrl({\n      endpoint: options.endpoint,\n      bucket: options.bucket,\n      storageKey,\n      pathStyle,\n    });\n\n    for (const [key, value] of Object.entries(queryParams)) {\n      if (value === undefined) {\n        continue;\n      }\n      url.searchParams.set(key, value);\n    }\n\n    return url;\n  };\n\n  const validateMetadata = (metadata?: Record<string, unknown> | null) => {\n    if (!metadata) {\n      return;\n    }\n\n    if (options.maxMetadataBytes === undefined) {\n      return;\n    }\n\n    if (resolveMetadataSize(metadata) > options.maxMetadataBytes) {\n      throw new Error(\"Metadata exceeds maximum size\");\n    }\n  };\n\n  return {\n    name: \"s3\",\n    capabilities: {\n      directUpload: true,\n      multipartUpload: true,\n      signedDownload: true,\n      proxyUpload: false,\n    },\n    limits: {\n      maxSingleUploadBytes,\n      maxMultipartUploadBytes,\n      minMultipartPartSizeBytes,\n      maxMultipartPartSizeBytes,\n      maxMultipartParts,\n      maxStorageKeyLengthBytes,\n      maxMetadataBytes: options.maxMetadataBytes,\n    },\n    recommendations: {\n      uploadExpiresInSeconds,\n      signedUrlExpiresInSeconds,\n      directUploadThresholdBytes,\n      multipartThresholdBytes,\n      multipartPartSizeBytes,\n    },\n    resolveStorageKey,\n    initUpload: async ({ fileKey, fileKeyParts, sizeBytes, contentType, metadata, checksum }) => {\n      validateMetadata(metadata);\n      const storageKey = resolveStorageKey({ fileKey, fileKeyParts });\n\n      const expiresAt = new Date(Date.now() + uploadExpiresInSeconds * 1000);\n      const sizeNumber = Number(sizeBytes);\n\n      if (Number.isNaN(sizeNumber) || sizeNumber < 0) {\n        throw new Error(\"Upload size must be a non-negative number\");\n      }\n\n      const canMultipart = sizeNumber <= maxMultipartUploadBytes;\n      const canSingle = sizeNumber <= maxSingleUploadBytes;\n\n      if (!canMultipart) {\n        throw new Error(\"Upload exceeds maximum multipart size\");\n      }\n\n      const prefersMultipart = sizeNumber >= multipartThresholdBytes;\n      const canUseSingle = canSingle && sizeNumber <= directUploadThresholdBytes;\n\n      if (prefersMultipart || !canUseSingle) {\n        if (!canMultipart) {\n          throw new Error(\"Upload exceeds maximum multipart size\");\n        }\n\n        const partSizeBytes = resolveMultipartPartSize({\n          sizeBytes,\n          desiredPartSizeBytes: multipartPartSizeBytes,\n          minPartSizeBytes: minMultipartPartSizeBytes,\n          maxPartSizeBytes: maxMultipartPartSizeBytes,\n          maxParts: maxMultipartParts,\n        });\n\n        const createUrl = buildUrl(storageKey, { uploads: \"\" });\n        const signed = await options.signer.sign({\n          method: \"POST\",\n          url: createUrl.toString(),\n          headers: {\n            \"Content-Type\": contentType,\n          },\n        });\n\n        const response = await fetch(signed.url, {\n          method: \"POST\",\n          headers: signed.headers,\n        });\n\n        if (!response.ok) {\n          throw new Error(`Failed to create multipart upload (${response.status})`);\n        }\n\n        const payload = await response.text();\n        const uploadId = parseUploadId(payload);\n        if (!uploadId) {\n          throw new Error(\"Failed to parse multipart upload id\");\n        }\n\n        return {\n          strategy: \"direct-multipart\",\n          storageKey,\n          storageUploadId: uploadId,\n          partSizeBytes,\n          expiresAt,\n        };\n      }\n\n      if (!canSingle) {\n        throw new Error(\"Upload exceeds maximum single upload size\");\n      }\n\n      const uploadUrl = buildUrl(storageKey);\n      const checksumHeaders = resolveChecksumHeaders(checksum);\n      const signed = await options.signer.presign({\n        method: \"PUT\",\n        url: uploadUrl.toString(),\n        headers: {\n          \"Content-Type\": contentType,\n          ...checksumHeaders,\n        },\n        expiresInSeconds: uploadExpiresInSeconds,\n      });\n\n      return {\n        strategy: \"direct-single\",\n        storageKey,\n        expiresAt,\n        uploadUrl: signed.url,\n        uploadHeaders: signed.headers,\n      };\n    },\n    getPartUploadUrls: async ({ storageKey, storageUploadId, partNumbers }) => {\n      for (const partNumber of partNumbers) {\n        if (partNumber < 1 || partNumber > maxMultipartParts) {\n          throw new Error(\"INVALID_REQUEST\");\n        }\n      }\n\n      const urls = await Promise.all(\n        partNumbers.map(async (partNumber) => {\n          const url = buildUrl(storageKey, {\n            partNumber: String(partNumber),\n            uploadId: storageUploadId,\n          });\n          const signed = await options.signer.presign({\n            method: \"PUT\",\n            url: url.toString(),\n            expiresInSeconds: uploadExpiresInSeconds,\n          });\n\n          return {\n            partNumber,\n            url: signed.url,\n            headers: signed.headers,\n          };\n        }),\n      );\n\n      return urls;\n    },\n    completeMultipartUpload: async ({ storageKey, storageUploadId, parts }) => {\n      const url = buildUrl(storageKey, { uploadId: storageUploadId });\n      const body = buildCompleteMultipartBody(parts);\n      const signed = await options.signer.sign({\n        method: \"POST\",\n        url: url.toString(),\n        headers: {\n          \"Content-Type\": \"application/xml\",\n        },\n        body,\n      });\n\n      const response = await fetch(signed.url, {\n        method: \"POST\",\n        headers: signed.headers,\n        body,\n      });\n\n      if (!response.ok) {\n        throw new Error(`Failed to complete multipart upload (${response.status})`);\n      }\n\n      const etag = response.headers.get(\"ETag\") ?? undefined;\n      return { etag };\n    },\n    abortMultipartUpload: async ({ storageKey, storageUploadId }) => {\n      const url = buildUrl(storageKey, { uploadId: storageUploadId });\n      const signed = await options.signer.sign({\n        method: \"DELETE\",\n        url: url.toString(),\n      });\n\n      const response = await fetch(signed.url, {\n        method: \"DELETE\",\n        headers: signed.headers,\n      });\n\n      if (!response.ok) {\n        throw new Error(`Failed to abort multipart upload (${response.status})`);\n      }\n    },\n    finalizeUpload: async ({ storageKey, expectedSizeBytes, checksum }) => {\n      const url = buildUrl(storageKey);\n      const signed = await options.signer.sign({\n        method: \"HEAD\",\n        url: url.toString(),\n      });\n\n      const response = await fetch(signed.url, {\n        method: \"HEAD\",\n        headers: signed.headers,\n      });\n\n      if (!response.ok) {\n        throw new Error(\"STORAGE_ERROR\");\n      }\n\n      const sizeHeader = getHeaderValue(response.headers, \"content-length\");\n      const sizeBytes = parseContentLength(sizeHeader);\n      if (sizeBytes === null) {\n        throw new Error(\"STORAGE_ERROR\");\n      }\n      if (sizeBytes !== expectedSizeBytes) {\n        throw new Error(\"INVALID_CHECKSUM\");\n      }\n\n      const normalized = normalizeChecksum(checksum);\n      if (normalized) {\n        if (normalized.algo === \"md5\") {\n          const etag = normalizeEtag(getHeaderValue(response.headers, \"etag\"));\n          if (etag) {\n            if (etag !== normalized.hex) {\n              throw new Error(\"INVALID_CHECKSUM\");\n            }\n          } else {\n            const signedGet = await options.signer.sign({\n              method: \"GET\",\n              url: buildUrl(storageKey).toString(),\n            });\n            const getResponse = await fetch(signedGet.url, {\n              method: \"GET\",\n              headers: signedGet.headers,\n            });\n            if (!getResponse.ok) {\n              throw new Error(\"STORAGE_ERROR\");\n            }\n            const computed = await computeChecksumFromResponse(getResponse, \"md5\");\n            if (computed !== normalized.hex) {\n              throw new Error(\"INVALID_CHECKSUM\");\n            }\n          }\n        } else {\n          const checksumHeader = getHeaderValue(response.headers, \"x-amz-checksum-sha256\");\n          if (checksumHeader) {\n            const remote = parseBase64(checksumHeader, 32);\n            if (!remote || remote.toString(\"base64\") !== normalized.base64) {\n              throw new Error(\"INVALID_CHECKSUM\");\n            }\n          } else {\n            const signedGet = await options.signer.sign({\n              method: \"GET\",\n              url: buildUrl(storageKey).toString(),\n            });\n            const getResponse = await fetch(signedGet.url, {\n              method: \"GET\",\n              headers: signedGet.headers,\n            });\n            if (!getResponse.ok) {\n              throw new Error(\"STORAGE_ERROR\");\n            }\n            const computed = await computeChecksumFromResponse(getResponse, \"sha256\");\n            if (computed !== normalized.hex) {\n              throw new Error(\"INVALID_CHECKSUM\");\n            }\n          }\n        }\n      }\n\n      const etag = getHeaderValue(response.headers, \"etag\");\n      return { sizeBytes, etag: etag ?? undefined };\n    },\n    deleteObject: async ({ storageKey }) => {\n      const url = buildUrl(storageKey);\n      const signed = await options.signer.sign({\n        method: \"DELETE\",\n        url: url.toString(),\n      });\n\n      const response = await fetch(signed.url, {\n        method: \"DELETE\",\n        headers: signed.headers,\n      });\n\n      if (!response.ok) {\n        throw new Error(`Failed to delete object (${response.status})`);\n      }\n    },\n    getDownloadUrl: async ({ storageKey, expiresInSeconds, contentDisposition, contentType }) => {\n      assertExpiresInSeconds(expiresInSeconds);\n\n      const url = buildUrl(storageKey, {\n        \"response-content-disposition\": contentDisposition,\n        \"response-content-type\": contentType,\n      });\n\n      const signed = await options.signer.presign({\n        method: \"GET\",\n        url: url.toString(),\n        expiresInSeconds,\n      });\n\n      return {\n        url: signed.url,\n        headers: signed.headers,\n        expiresAt: new Date(Date.now() + expiresInSeconds * 1000),\n      };\n    },\n  };\n}\n"],"mappings":"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"}