@finueva/drive 0.2.0 → 0.3.0

package/dist/index.js

@@ -10,6 +10,7 @@ const DRIVE_API_ERROR_CODES = Object.freeze([
 	"precondition_failed",
 	"idempotency_conflict",
 	"quota_exceeded",
+	"upload_recovery_required",
 	"service_unavailable",
 	"internal_error"
 ]);
@@ -24,6 +25,7 @@ const DRIVE_API_ERROR_MESSAGES = Object.freeze({
 	precondition_failed: "The request precondition failed.",
 	idempotency_conflict: "The idempotency key conflicts with an earlier request.",
 	quota_exceeded: "The workspace storage quota would be exceeded.",
+	upload_recovery_required: "The upload requires recovery before it can continue.",
 	service_unavailable: "The service is temporarily unavailable.",
 	internal_error: "The request could not be completed."
 });
@@ -79,6 +81,28 @@ async function parseResponse(response, operationSignal, preconditionStatus, succ
 		validators: readValidators(response.headers)
 	});
 }
+async function parseNoContentResponse(response, operationSignal, preconditionStatus, successStatuses, allowedErrorCodes) {
+	const requestId = safeRequestId(response.headers.get("x-request-id"));
+	if (requestId === null) {
+		cancelResponse(response);
+		throw new DriveError("invalid_response", { status: response.status });
+	}
+	if (!successStatuses.includes(response.status)) throw await normalizeError(response, requestId, operationSignal, preconditionStatus, false, allowedErrorCodes);
+	const contentLength = response.headers.get("content-length");
+	if (response.body !== null || contentLength !== null && contentLength !== "0" || response.headers.has("content-type")) {
+		cancelResponse(response);
+		throw new DriveError("invalid_response", {
+			status: response.status,
+			requestId
+		});
+	}
+	return Object.freeze({
+		data: void 0,
+		status: response.status,
+		requestId,
+		validators: Object.freeze({})
+	});
+}
 function parseCollectionEtag(value) {
 	const match = COLLECTION_ETAG.exec(value);
 	if (!match) return void 0;
@@ -137,6 +161,7 @@ function errorStatusMatches(code, status, preconditionStatus, allowsQuotaExceede
 		precondition_failed: preconditionStatus === null ? [] : [preconditionStatus],
 		idempotency_conflict: [409],
 		quota_exceeded: [409],
+		upload_recovery_required: [409],
 		service_unavailable: [503],
 		internal_error: [500]
 	}[code].includes(status);
@@ -247,6 +272,7 @@ const WORKSPACE_ID$1 = /^drive\.workspace\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-
 const VOLUME_ID = /^drive\.volume\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const GRANT_ID$1 = /^drive\.grant\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const UPLOAD_ID$1 = /^drive\.upload\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const VERSION_ID = /^drive\.version\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const CURSOR$1 = /^drive\.cursor\.v1\.[A-Za-z0-9_-]+$/;
 const AUTH_ID$1 = /^[A-Za-z0-9_-]{1,128}$/;
 const GRANT_ETAG = /^"drive\.permission-grant\.v1\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)"$/;
@@ -269,7 +295,8 @@ const EFFECTIVE_ACTIONS = Object.freeze([
 	"items:update"
 ]);
 const MAX_UPLOAD_BYTE_LENGTH$1 = 33554432e4;
-const UPLOAD_QUOTA_EXPIRY_MILLISECONDS = 864e5;
+const UPLOAD_PART_BYTE_LENGTH$2 = 32 * 1024 * 1024;
+const CONTENT_DIGEST$1 = /^sha256:[0-9a-f]{64}$/;
 function isCurrentWorkspace(value) {
 	if (!isExactRecord(value, [
 		"workspaceId",
@@ -350,18 +377,93 @@ function isEffectivePermissionResponse(value, targetItemId) {
 	}
 	return true;
 }
-function isUploadQuotaReservation(value) {
-	return isExactRecord(value, [
-		"workspaceId",
+function isUploadSession(value, expectedByteLength) {
+	if (!isExactRecord(value, [
+		"itemId",
+		"versionId",
 		"uploadId",
-		"parentItemId",
-		"expectedByteLength",
-		"state",
-		"terminalReason",
-		"createdAtEpochMilliseconds",
+		"mode",
+		"partByteLength",
+		"partCount",
+		"revision",
+		"expiresAtEpochMilliseconds"
+	]) || typeof value.itemId !== "string" || !ITEM_ID$1.test(value.itemId) || typeof value.versionId !== "string" || !VERSION_ID.test(value.versionId) || typeof value.uploadId !== "string" || !UPLOAD_ID$1.test(value.uploadId) || value.mode !== "presigned-multipart" && value.mode !== "server-mediated-zero-byte" || value.partByteLength !== UPLOAD_PART_BYTE_LENGTH$2 || !isSafeInteger$1(value.partCount) || value.partCount > 1e4 || value.partCount !== Math.ceil(expectedByteLength / UPLOAD_PART_BYTE_LENGTH$2) || (expectedByteLength === 0 ? value.mode !== "server-mediated-zero-byte" : value.mode !== "presigned-multipart") || !isSafeInteger$1(value.revision) || !isSafeInteger$1(value.expiresAtEpochMilliseconds) || value.expiresAtEpochMilliseconds <= Date.now()) return false;
+	Object.freeze(value);
+	return true;
+}
+function isUploadStatus(value, afterPartNumber, limit) {
+	if (!isExactRecord(value, [
+		"itemId",
+		"versionId",
+		"uploadId",
+		"mode",
+		"lifecycle",
+		"revision",
+		"partPolicy",
+		"confirmedParts",
+		"nextAfterPartNumber",
 		"expiresAtEpochMilliseconds",
-		"terminalAtEpochMilliseconds"
-	]) && typeof value.workspaceId === "string" && WORKSPACE_ID$1.test(value.workspaceId) && typeof value.uploadId === "string" && UPLOAD_ID$1.test(value.uploadId) && typeof value.parentItemId === "string" && ITEM_ID$1.test(value.parentItemId) && typeof value.expectedByteLength === "number" && Number.isSafeInteger(value.expectedByteLength) && value.expectedByteLength >= 0 && value.expectedByteLength <= MAX_UPLOAD_BYTE_LENGTH$1 && (value.state === "reserved" || value.state === "converted" || value.state === "released") && (value.terminalReason === null || value.terminalReason === "completed" || value.terminalReason === "aborted" || value.terminalReason === "failed" || value.terminalReason === "expired") && isSafeInteger$1(value.createdAtEpochMilliseconds) && isSafeInteger$1(value.expiresAtEpochMilliseconds) && value.expiresAtEpochMilliseconds - value.createdAtEpochMilliseconds === UPLOAD_QUOTA_EXPIRY_MILLISECONDS && (value.terminalAtEpochMilliseconds === null || isSafeInteger$1(value.terminalAtEpochMilliseconds) && value.terminalAtEpochMilliseconds >= value.createdAtEpochMilliseconds);
+		"ready"
+	]) || typeof value.itemId !== "string" || !ITEM_ID$1.test(value.itemId) || typeof value.versionId !== "string" || !VERSION_ID.test(value.versionId) || typeof value.uploadId !== "string" || !UPLOAD_ID$1.test(value.uploadId) || value.mode !== "presigned-multipart" && value.mode !== "server-mediated-zero-byte" || ![
+		"initiating",
+		"recovery-required",
+		"uploading",
+		"completing",
+		"provider-completed",
+		"ready",
+		"aborting",
+		"aborted"
+	].includes(String(value.lifecycle)) || !isSafeInteger$1(value.revision) || !isExactRecord(value.partPolicy, [
+		"partByteLength",
+		"partCount",
+		"maxParts"
+	]) || value.partPolicy.partByteLength !== UPLOAD_PART_BYTE_LENGTH$2 || !isSafeInteger$1(value.partPolicy.partCount) || value.partPolicy.partCount > 1e4 || value.partPolicy.maxParts !== 1e4 || (value.mode === "server-mediated-zero-byte" ? value.partPolicy.partCount !== 0 : value.partPolicy.partCount < 1) || !Array.isArray(value.confirmedParts) || value.confirmedParts.length > limit || !isSafeInteger$1(value.expiresAtEpochMilliseconds)) return false;
+	let previousPartNumber = afterPartNumber;
+	for (const part of value.confirmedParts) {
+		if (!isExactRecord(part, ["partNumber", "checksumSha256"]) || !isSafeInteger$1(part.partNumber) || part.partNumber <= previousPartNumber || part.partNumber > value.partPolicy.partCount || !isPartChecksum$1(part.checksumSha256)) return false;
+		previousPartNumber = part.partNumber;
+	}
+	if (!(value.nextAfterPartNumber === null || isSafeInteger$1(value.nextAfterPartNumber) && value.confirmedParts.length === limit && value.nextAfterPartNumber === previousPartNumber) || value.mode === "server-mediated-zero-byte" && (value.confirmedParts.length !== 0 || value.nextAfterPartNumber !== null) || value.lifecycle === "ready" !== (value.ready !== null) || value.ready !== null && (!isReadyUpload(value.ready, { uploadId: value.uploadId }) || value.ready.itemId !== value.itemId || value.ready.versionId !== value.versionId)) return false;
+	Object.freeze(value.partPolicy);
+	for (const part of value.confirmedParts) Object.freeze(part);
+	Object.freeze(value.confirmedParts);
+	Object.freeze(value);
+	return true;
+}
+function isUploadPartDescriptor(value, expectedPartNumber, checksumSha256, allowInsecureHttp) {
+	if (!isExactRecord(value, [
+		"url",
+		"method",
+		"headers",
+		"partNumber",
+		"expectedByteLength",
+		"expiresAtEpochMilliseconds"
+	]) || !isSignedTransferUrl(value.url, allowInsecureHttp) || value.method !== "PUT" || !isExactRecord(value.headers, ["x-amz-checksum-sha256"]) || value.headers["x-amz-checksum-sha256"] !== checksumSha256 || value.partNumber !== expectedPartNumber || !isSafeInteger$1(value.expectedByteLength) || value.expectedByteLength < 1 || value.expectedByteLength > UPLOAD_PART_BYTE_LENGTH$2 || !isSafeInteger$1(value.expiresAtEpochMilliseconds) || value.expiresAtEpochMilliseconds <= Date.now()) return false;
+	Object.freeze(value.headers);
+	Object.freeze(value);
+	return true;
+}
+function isUploadPartResult(value, expectedPartNumber, expectedUploadRevision) {
+	if (!isExactRecord(value, ["partNumber", "revision"]) || value.partNumber !== expectedPartNumber || value.revision !== expectedUploadRevision + 1 || !isSafeInteger$1(value.revision)) return false;
+	Object.freeze(value);
+	return true;
+}
+function isReadyUpload(value, expected) {
+	if (!isExactRecord(value, [
+		"itemId",
+		"versionId",
+		"uploadId",
+		"byteLength",
+		"callerDeclaredContentDigest",
+		"displayFilename",
+		"mediaType",
+		"state"
+	]) || typeof value.itemId !== "string" || !ITEM_ID$1.test(value.itemId) || typeof value.versionId !== "string" || !VERSION_ID.test(value.versionId) || value.uploadId !== expected.uploadId || !isSafeInteger$1(value.byteLength) || value.byteLength < 0 || value.byteLength > MAX_UPLOAD_BYTE_LENGTH$1 || typeof value.callerDeclaredContentDigest !== "string" || !CONTENT_DIGEST$1.test(value.callerDeclaredContentDigest) || !isSafeFilename$1(value.displayFilename) || !isMediaType$1(value.mediaType) || value.state !== "ready" || expected.byteLength !== void 0 && value.byteLength !== expected.byteLength || expected.callerDeclaredContentDigest !== void 0 && value.callerDeclaredContentDigest !== expected.callerDeclaredContentDigest || expected.displayFilename !== void 0 && value.displayFilename !== expected.displayFilename || expected.mediaType !== void 0 && value.mediaType !== expected.mediaType) return false;
+	Object.freeze(value);
+	return true;
+}
+function isPartChecksum$1(value) {
+	return typeof value === "string" && /^[A-Za-z0-9+/]{42}[AEIMQUYcgkosw048]=$/.test(value);
 }
 function mutationValidatorsAreCoherent(headers) {
 	const collection = headers.get("drive-permission-collection-etag");
@@ -418,6 +520,19 @@ function isSafeFilename$1(value) {
 	}
 	return true;
 }
+function isMediaType$1(value) {
+	return typeof value === "string" && value.length <= 255 && /^[a-z0-9](?:[a-z0-9!#$&^_.+-]{0,125}[a-z0-9])?\/[a-z0-9](?:[a-z0-9!#$&^_.+-]{0,125}[a-z0-9])?$/.test(value);
+}
+function isSignedTransferUrl(value, allowInsecureHttp) {
+	if (typeof value !== "string" || value.length < 1 || value.length > 8192 || value !== value.trim()) return false;
+	try {
+		const url = new URL(value);
+		const loopbackHost = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+		return (url.protocol === "https:" || url.protocol === "http:" && allowInsecureHttp && loopbackHost) && url.username === "" && url.password === "" && url.hash === "" && url.host !== "";
+	} catch {
+		return false;
+	}
+}
 function filenameIsReserved$1(value) {
 	const base = value.split(".", 1)[0].toUpperCase();
 	return value === "." || value === ".." || [
@@ -457,7 +572,10 @@ const PERMISSION_ACTIONS = Object.freeze([
 	"items:update"
 ]);
 const IDEMPOTENCY_KEY = /^[A-Za-z0-9_-]{16,128}$/;
+const CONTENT_DIGEST = /^sha256:[0-9a-f]{64}$/;
+const PART_CHECKSUM = /^[A-Za-z0-9+/]{42}[AEIMQUYcgkosw048]=$/;
 const MAX_UPLOAD_BYTE_LENGTH = 33554432e4;
+const UPLOAD_PART_BYTE_LENGTH$1 = 32 * 1024 * 1024;
 function validateCurrentWorkspaceInput(value) {
 	const signal = validateSignal(captureRecord(value === void 0 ? {} : value, [], ["signal"]).signal);
 	return signal === void 0 ? {} : { signal };
@@ -596,26 +714,133 @@ function validateCreateUploadInput(value) {
 		"workspaceId",
 		"parentItemId",
 		"expectedByteLength",
+		"displayFilename",
+		"mediaType",
+		"callerDeclaredContentDigest",
+		"protectionClassification",
 		"idempotencyKey"
 	], ["signal"]);
 	const signal = validateSignal(input.signal);
-	if (typeof input.workspaceId !== "string" || !WORKSPACE_ID.test(input.workspaceId) || typeof input.parentItemId !== "string" || !ITEM_ID.test(input.parentItemId) || typeof input.expectedByteLength !== "number" || !Number.isSafeInteger(input.expectedByteLength) || input.expectedByteLength < 0 || input.expectedByteLength > MAX_UPLOAD_BYTE_LENGTH || !isIdempotencyKey(input.idempotencyKey)) throw new DriveError("invalid_input");
+	if (typeof input.workspaceId !== "string" || !WORKSPACE_ID.test(input.workspaceId) || typeof input.parentItemId !== "string" || !ITEM_ID.test(input.parentItemId) || typeof input.expectedByteLength !== "number" || !Number.isSafeInteger(input.expectedByteLength) || input.expectedByteLength < 0 || input.expectedByteLength > MAX_UPLOAD_BYTE_LENGTH || !isSafeFilename(input.displayFilename) || !isMediaType(input.mediaType) || typeof input.callerDeclaredContentDigest !== "string" || !CONTENT_DIGEST.test(input.callerDeclaredContentDigest) || input.protectionClassification !== "ordinary" && input.protectionClassification !== "opaque-encrypted" || !isIdempotencyKey(input.idempotencyKey)) throw new DriveError("invalid_input");
 	return {
 		workspaceId: input.workspaceId,
 		parentItemId: input.parentItemId,
 		expectedByteLength: input.expectedByteLength,
+		displayFilename: input.displayFilename,
+		mediaType: input.mediaType,
+		callerDeclaredContentDigest: input.callerDeclaredContentDigest,
+		protectionClassification: input.protectionClassification,
 		idempotencyKey: input.idempotencyKey,
 		...signal === void 0 ? {} : { signal }
 	};
 }
+function validateGetUploadStatusInput(value) {
+	const input = captureRecord(value, ["workspaceId", "uploadId"], [
+		"afterPartNumber",
+		"limit",
+		"signal"
+	]);
+	const upload = validateUploadPath(input.workspaceId, input.uploadId, input.signal);
+	if (input.afterPartNumber !== void 0 && (!isSafeInteger(input.afterPartNumber) || input.afterPartNumber > 1e4) || input.limit !== void 0 && (!isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100)) throw new DriveError("invalid_input");
+	return {
+		...upload,
+		...input.afterPartNumber === void 0 ? {} : { afterPartNumber: input.afterPartNumber },
+		...input.limit === void 0 ? {} : { limit: input.limit }
+	};
+}
+function validateCreateUploadPartDescriptorInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"uploadId",
+		"partNumber",
+		"checksumSha256"
+	], ["signal"]);
+	const upload = validateUploadPath(input.workspaceId, input.uploadId, input.signal);
+	if (!isPartNumber(input.partNumber) || !isPartChecksum(input.checksumSha256)) throw new DriveError("invalid_input");
+	return {
+		...upload,
+		partNumber: input.partNumber,
+		checksumSha256: input.checksumSha256
+	};
+}
+function validateRecordUploadPartInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"uploadId",
+		"partNumber",
+		"expectedUploadRevision",
+		"byteLength",
+		"etag",
+		"checksumSha256"
+	], ["signal"]);
+	const upload = validateUploadPath(input.workspaceId, input.uploadId, input.signal);
+	if (!isPartNumber(input.partNumber) || !isSafeInteger(input.expectedUploadRevision) || input.expectedUploadRevision >= Number.MAX_SAFE_INTEGER || !isSafeInteger(input.byteLength) || input.byteLength < 1 || input.byteLength > UPLOAD_PART_BYTE_LENGTH$1 || !isEtag$1(input.etag) || !isPartChecksum(input.checksumSha256)) throw new DriveError("invalid_input");
+	return {
+		...upload,
+		partNumber: input.partNumber,
+		expectedUploadRevision: input.expectedUploadRevision,
+		byteLength: input.byteLength,
+		etag: input.etag,
+		checksumSha256: input.checksumSha256
+	};
+}
+function validateCompleteUploadInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"uploadId",
+		"idempotencyKey"
+	], ["signal"]);
+	const upload = validateUploadPath(input.workspaceId, input.uploadId, input.signal);
+	if (!isIdempotencyKey(input.idempotencyKey)) throw new DriveError("invalid_input");
+	return {
+		...upload,
+		idempotencyKey: input.idempotencyKey
+	};
+}
 function validateAbortUploadInput(value) {
 	const input = captureRecord(value, ["workspaceId", "uploadId"], ["signal"]);
+	return validateUploadPath(input.workspaceId, input.uploadId, input.signal);
+}
+function validateUploadFileInput(value) {
+	const input = captureRecord(value, [
+		"workspaceId",
+		"parentItemId",
+		"source",
+		"displayFilename",
+		"idempotencyKey",
+		"completionIdempotencyKey"
+	], [
+		"mediaType",
+		"protectionClassification",
+		"signal",
+		"onProgress"
+	]);
 	const signal = validateSignal(input.signal);
-	if (typeof input.workspaceId !== "string" || !WORKSPACE_ID.test(input.workspaceId) || typeof input.uploadId !== "string" || !UPLOAD_ID.test(input.uploadId)) throw new DriveError("invalid_input");
+	const mediaType = input.mediaType ?? "application/octet-stream";
+	const protectionClassification = input.protectionClassification ?? "ordinary";
+	let source;
+	let byteLength;
+	try {
+		if (!(input.source instanceof Blob)) throw new DriveError("invalid_input");
+		source = input.source;
+		byteLength = source.size;
+	} catch (error) {
+		if (error instanceof DriveError) throw error;
+		throw new DriveError("invalid_input");
+	}
+	if (typeof input.workspaceId !== "string" || !WORKSPACE_ID.test(input.workspaceId) || typeof input.parentItemId !== "string" || !ITEM_ID.test(input.parentItemId) || !Number.isSafeInteger(byteLength) || byteLength < 0 || byteLength > MAX_UPLOAD_BYTE_LENGTH || !isSafeFilename(input.displayFilename) || !isMediaType(mediaType) || protectionClassification !== "ordinary" && protectionClassification !== "opaque-encrypted" || !isIdempotencyKey(input.idempotencyKey) || !isIdempotencyKey(input.completionIdempotencyKey) || input.onProgress !== void 0 && typeof input.onProgress !== "function") throw new DriveError("invalid_input");
 	return {
 		workspaceId: input.workspaceId,
-		uploadId: input.uploadId,
-		...signal === void 0 ? {} : { signal }
+		parentItemId: input.parentItemId,
+		source,
+		byteLength,
+		displayFilename: input.displayFilename,
+		mediaType,
+		protectionClassification,
+		idempotencyKey: input.idempotencyKey,
+		completionIdempotencyKey: input.completionIdempotencyKey,
+		...signal === void 0 ? {} : { signal },
+		...input.onProgress === void 0 ? {} : { onProgress: input.onProgress }
 	};
 }
 function resourcePath(input) {
@@ -702,6 +927,27 @@ function captureArray(value) {
 function isIdempotencyKey(value) {
 	return typeof value === "string" && IDEMPOTENCY_KEY.test(value);
 }
+function validateUploadPath(workspaceId, uploadId, signalValue) {
+	const signal = validateSignal(signalValue);
+	if (typeof workspaceId !== "string" || !WORKSPACE_ID.test(workspaceId) || typeof uploadId !== "string" || !UPLOAD_ID.test(uploadId)) throw new DriveError("invalid_input");
+	return {
+		workspaceId,
+		uploadId,
+		...signal === void 0 ? {} : { signal }
+	};
+}
+function isPartNumber(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 && value <= 1e4;
+}
+function isPartChecksum(value) {
+	return typeof value === "string" && PART_CHECKSUM.test(value);
+}
+function isEtag$1(value) {
+	return typeof value === "string" && value.length >= 1 && value.length <= 1024 && /^[\x20-\x7e]+$/.test(value);
+}
+function isMediaType(value) {
+	return typeof value === "string" && value.length <= 255 && /^[a-z0-9](?:[a-z0-9!#$&^_.+-]{0,125}[a-z0-9])?\/[a-z0-9](?:[a-z0-9!#$&^_.+-]{0,125}[a-z0-9])?$/.test(value);
+}
 function isExpiry(value) {
 	return value === null || isSafeInteger(value);
 }
@@ -1188,7 +1434,7 @@ async function execute(runtime, signal, preconditionStatus, send, successStatuse
 			signal: operationSignal
 		});
 		if (!capturedResponse) throw new DriveError("network_error");
-		return await parseResponse(capturedResponse, operationSignal, preconditionStatus, successStatuses, guard, allowsQuotaExceeded, allowedErrorCodes);
+		return guard === null ? await parseNoContentResponse(capturedResponse, operationSignal, preconditionStatus, successStatuses, allowedErrorCodes) : await parseResponse(capturedResponse, operationSignal, preconditionStatus, successStatuses, guard, allowsQuotaExceeded, allowedErrorCodes);
 	} catch (error) {
 		if (operation.didTimeout()) throw new DriveError("timeout");
 		if (error instanceof DriveError) throw error;
@@ -1276,8 +1522,32 @@ const CURRENT_WORKSPACE_ERROR_CODES = Object.freeze([
 	"invalid_request",
 	"service_unavailable"
 ]);
-function createDriveClientInternal(config) {
-	const runtime = createClientRuntime(config);
+const TRANSFER_ERROR_CODES = Object.freeze([
+	"authentication_required",
+	"identity_authority_unavailable",
+	"permission_denied",
+	"resource_not_found",
+	"invalid_request",
+	"precondition_failed",
+	"upload_recovery_required",
+	"service_unavailable"
+]);
+const STATUS_ERROR_CODES = Object.freeze([
+	"authentication_required",
+	"identity_authority_unavailable",
+	"permission_denied",
+	"resource_not_found",
+	"invalid_request",
+	"service_unavailable"
+]);
+const CREATE_UPLOAD_ERROR_CODES = Object.freeze([
+	...TRANSFER_ERROR_CODES,
+	"invalid_idempotency_key",
+	"idempotency_conflict",
+	"quota_exceeded"
+]);
+const COMPLETE_UPLOAD_ERROR_CODES = Object.freeze([...TRANSFER_ERROR_CODES, "invalid_idempotency_key"]);
+function createDriveOperations(runtime) {
 	return Object.freeze({
 		getCurrentWorkspace: (input) => getCurrentWorkspace(runtime, input),
 		listFolderChildren: (input) => listFolderChildren(runtime, input),
@@ -1288,6 +1558,10 @@ function createDriveClientInternal(config) {
 		updateItemPermission: (input) => updateItemPermission(runtime, input),
 		revokeItemPermission: (input) => revokeItemPermission(runtime, input),
 		createUpload: (input) => createUpload(runtime, input),
+		getUploadStatus: (input) => getUploadStatus(runtime, input),
+		createUploadPartDescriptor: (input) => createUploadPartDescriptor(runtime, input),
+		recordUploadPart: (input) => recordUploadPart(runtime, input),
+		completeUpload: (input) => completeUpload(runtime, input),
 		abortUpload: (input) => abortUpload(runtime, input)
 	});
 }
@@ -1405,11 +1679,81 @@ async function createUpload(runtime, input) {
 			},
 			body: {
 				parentItemId: validated.parentItemId,
-				expectedByteLength: validated.expectedByteLength
+				expectedByteLength: validated.expectedByteLength,
+				displayFilename: validated.displayFilename,
+				mediaType: validated.mediaType,
+				callerDeclaredContentDigest: validated.callerDeclaredContentDigest,
+				protectionClassification: validated.protectionClassification
+			}
+		}),
+		...requestOptions
+	}), [200, 201], (value) => isUploadSession(value, validated.expectedByteLength), true, CREATE_UPLOAD_ERROR_CODES);
+}
+async function getUploadStatus(runtime, input) {
+	const validated = validateGetUploadStatusInput(input);
+	const afterPartNumber = validated.afterPartNumber ?? 0;
+	const limit = validated.limit ?? 100;
+	return execute(runtime, validated.signal, null, (api, requestOptions) => api.GET("/api/v1/workspaces/{workspaceId}/uploads/{uploadId}", {
+		...operationOptions("getUploadStatus", { params: {
+			path: {
+				workspaceId: validated.workspaceId,
+				uploadId: validated.uploadId
+			},
+			query: {
+				...validated.afterPartNumber === void 0 ? {} : { afterPartNumber: String(validated.afterPartNumber) },
+				...validated.limit === void 0 ? {} : { limit: String(validated.limit) }
+			}
+		} }),
+		...requestOptions
+	}), [200], (value) => isUploadStatus(value, afterPartNumber, limit), false, STATUS_ERROR_CODES);
+}
+async function createUploadPartDescriptor(runtime, input) {
+	const validated = validateCreateUploadPartDescriptorInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/uploads/{uploadId}/parts", {
+		...operationOptions("createUploadPartDescriptor", {
+			params: { path: {
+				workspaceId: validated.workspaceId,
+				uploadId: validated.uploadId
+			} },
+			body: {
+				partNumber: validated.partNumber,
+				checksumSha256: validated.checksumSha256
 			}
 		}),
 		...requestOptions
-	}), [200, 201], (value) => isUploadQuotaReservation(value) && value.workspaceId === validated.workspaceId && value.parentItemId === validated.parentItemId && value.expectedByteLength === validated.expectedByteLength && value.state === "reserved" && value.terminalReason === null && value.terminalAtEpochMilliseconds === null, true);
+	}), [200], (value) => isUploadPartDescriptor(value, validated.partNumber, validated.checksumSha256, new URL(runtime.baseUrl).protocol === "http:"), false, TRANSFER_ERROR_CODES);
+}
+async function recordUploadPart(runtime, input) {
+	const validated = validateRecordUploadPartInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/uploads/{uploadId}/parts/{partNumber}", {
+		...operationOptions("recordUploadPart", {
+			params: { path: {
+				workspaceId: validated.workspaceId,
+				uploadId: validated.uploadId,
+				partNumber: String(validated.partNumber)
+			} },
+			body: {
+				expectedUploadRevision: validated.expectedUploadRevision,
+				byteLength: validated.byteLength,
+				etag: validated.etag,
+				checksumSha256: validated.checksumSha256
+			}
+		}),
+		...requestOptions
+	}), [200], (value) => isUploadPartResult(value, validated.partNumber, validated.expectedUploadRevision), false, TRANSFER_ERROR_CODES);
+}
+async function completeUpload(runtime, input) {
+	const validated = validateCompleteUploadInput(input);
+	return execute(runtime, validated.signal, 409, (api, requestOptions) => api.POST("/api/v1/workspaces/{workspaceId}/uploads/{uploadId}/complete", {
+		...operationOptions("completeUpload", { params: {
+			path: {
+				workspaceId: validated.workspaceId,
+				uploadId: validated.uploadId
+			},
+			header: { "Idempotency-Key": validated.idempotencyKey }
+		} }),
+		...requestOptions
+	}), [200], (value) => isReadyUpload(value, { uploadId: validated.uploadId }), false, COMPLETE_UPLOAD_ERROR_CODES);
 }
 async function abortUpload(runtime, input) {
 	const validated = validateAbortUploadInput(input);
@@ -1419,12 +1763,717 @@ async function abortUpload(runtime, input) {
 			uploadId: validated.uploadId
 		} } }),
 		...requestOptions
-	}), [200], (value) => isUploadQuotaReservation(value) && value.workspaceId === validated.workspaceId && value.uploadId === validated.uploadId && value.state === "released" && value.terminalReason === "aborted" && value.terminalAtEpochMilliseconds !== null);
+	}), [204], null, false, TRANSFER_ERROR_CODES);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.3.0/node_modules/@noble/hashes/_u64.js
+const fromNumH = (n) => n / 2 ** 32 | 0;
+const fromNumL = (n) => n >>> 0;
+function setU64FromNum(view, byteOffset, n, isLE) {
+	const h = fromNumH(n);
+	const l = fromNumL(n);
+	view.setUint32(byteOffset, isLE ? l : h, isLE);
+	view.setUint32(byteOffset + 4, isLE ? h : l, isLE);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.3.0/node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+const atitle = (title) => title ? `"${title}" ` : "";
+function anumber(n, title = "") {
+	if (typeof n !== "number") throw new TypeError(atitle(title) + "expected number, got " + typeof n);
+	if (!Number.isSafeInteger(n) || n < 0) throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
+	return n;
+}
+function abytes(value, length, title = "") {
+	if (isBytes(value) && (length === void 0 || value.length === length)) return value;
+	if (length !== void 0) anumber(length, "length");
+	const bytes = isBytes(value);
+	const ofLen = length !== void 0 ? ` of length ${length}` : "";
+	const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+	const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+	if (!bytes) throw new TypeError(message);
+	throw new RangeError(message);
+}
+const aobject = (value, label) => {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
+};
+function aexists(instance, checkFinished = true) {
+	if (instance.destroyed) throw new Error("hash was destroyed");
+	if (checkFinished && instance.finished) throw new Error("digest() was already called");
+}
+function aoutput(out, instance) {
+	abytes(out, void 0, "output");
+	const min = instance.outputLen;
+	if (!(out.length >= min)) throw new RangeError("\"output\" expected length >= " + min);
+}
+function clean(...arrays) {
+	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+}
+function createView(arr) {
+	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+	return word << 32 - shift | word >>> shift;
+}
+const hasHexBuiltin = (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+const hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+	abytes(bytes);
+	if (hasHexBuiltin) return bytes.toHex();
+	let hex = "";
+	for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
+	return hex;
+}
+function checkOpts(defaults, opts, title = "opts") {
+	aobject(defaults, "defaults");
+	if (opts !== void 0) aobject(opts, title);
+	return Object.assign(defaults, opts);
+}
+function createHasher(hashCons, info = {}) {
+	if (typeof hashCons !== "function") throw new TypeError("\"hashCons\" expected function, got type=" + typeof hashCons);
+	info = checkOpts({}, info, "info");
+	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+	const tmp = hashCons(void 0);
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.canXOF = tmp.canXOF;
+	hashC.create = (opts) => hashCons(opts);
+	Object.assign(hashC, info);
+	return Object.freeze(hashC);
+}
+const oidNist = (suffix) => ({ oid: Uint8Array.from([
+	6,
+	9,
+	96,
+	134,
+	72,
+	1,
+	101,
+	3,
+	4,
+	2,
+	suffix
+]) });
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.3.0/node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+	return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+	return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+	blockLen;
+	outputLen;
+	canXOF = false;
+	padOffset;
+	isLE;
+	buffer;
+	view;
+	finished = false;
+	length = 0;
+	pos = 0;
+	destroyed = false;
+	constructor(blockLen, outputLen, padOffset, isLE) {
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.padOffset = padOffset;
+		this.isLE = isLE;
+		this.buffer = new Uint8Array(blockLen);
+		this.view = createView(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		abytes(data);
+		const { view, buffer, blockLen } = this;
+		const len = data.length;
+		let processed = false;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			if (take === blockLen) {
+				const dataView = createView(data);
+				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
+				processed = true;
+				continue;
+			}
+			buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);
+			this.pos += take;
+			pos += take;
+			if (this.pos === blockLen) {
+				this.process(view, 0);
+				this.pos = 0;
+				processed = true;
+			}
+		}
+		this.length += data.length;
+		if (processed) this.roundClean();
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		aoutput(out, this);
+		this.finished = true;
+		const { buffer, view, blockLen, isLE } = this;
+		let { pos } = this;
+		buffer[pos++] = 128;
+		buffer.fill(0, pos);
+		if (this.padOffset > blockLen - pos) {
+			this.process(view, 0);
+			buffer.fill(0);
+		}
+		setU64FromNum(view, blockLen - 8, this.length * 8, isLE);
+		this.process(view, 0);
+		this.roundClean();
+		const oview = out === buffer ? view : createView(out);
+		const len = this.outputLen;
+		const outLen = len / 4;
+		const state = this.get();
+		if (len % 4 || outLen > state.length) throw new Error("invalid outputLen");
+		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
+	}
+	digest() {
+		const { buffer, outputLen } = this;
+		this.digestInto(buffer);
+		const res = buffer.slice(0, outputLen);
+		this.destroy();
+		return res;
+	}
+	_cloneIntoMeta(to) {
+		const { buffer, length, finished, destroyed, pos } = this;
+		to.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		if (pos) to.buffer.set(buffer);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+const SHA256_IV = Uint32Array.from([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]);
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.3.0/node_modules/@noble/hashes/sha2.js
+const SHA256_K = Uint32Array.from([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+const SHA256_W = new Uint32Array(64);
+var SHA2_32B = class extends HashMD {
+	A = 0;
+	B = 0;
+	C = 0;
+	D = 0;
+	E = 0;
+	F = 0;
+	G = 0;
+	H = 0;
+	constructor(outputLen, IV) {
+		super(64, outputLen, 8, false);
+		this.A = IV[0] | 0;
+		this.B = IV[1] | 0;
+		this.C = IV[2] | 0;
+		this.D = IV[3] | 0;
+		this.E = IV[4] | 0;
+		this.F = IV[5] | 0;
+		this.G = IV[6] | 0;
+		this.H = IV[7] | 0;
+	}
+	get() {
+		const { A, B, C, D, E, F, G, H } = this;
+		return [
+			A,
+			B,
+			C,
+			D,
+			E,
+			F,
+			G,
+			H
+		];
+	}
+	set(A, B, C, D, E, F, G, H) {
+		this.A = A | 0;
+		this.B = B | 0;
+		this.C = C | 0;
+		this.D = D | 0;
+		this.E = E | 0;
+		this.F = F | 0;
+		this.G = G | 0;
+		this.H = H | 0;
+	}
+	_cloneInto(to) {
+		(to ||= new this.constructor()).set(...this.get());
+		return this._cloneIntoMeta(to);
+	}
+	process(view, offset) {
+		for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
+		for (let i = 16; i < 64; i++) {
+			const W15 = SHA256_W[i - 15];
+			const W2 = SHA256_W[i - 2];
+			const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+			const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+			SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+		}
+		let { A, B, C, D, E, F, G, H } = this;
+		for (let i = 0; i < 64; i++) {
+			const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+			const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+			const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Maj(A, B, C) | 0;
+			H = G;
+			G = F;
+			F = E;
+			E = D + T1 | 0;
+			D = C;
+			C = B;
+			B = A;
+			A = T1 + T2 | 0;
+		}
+		A = A + this.A | 0;
+		B = B + this.B | 0;
+		C = C + this.C | 0;
+		D = D + this.D | 0;
+		E = E + this.E | 0;
+		F = F + this.F | 0;
+		G = G + this.G | 0;
+		H = H + this.H | 0;
+		this.set(A, B, C, D, E, F, G, H);
+	}
+	roundClean() {
+		clean(SHA256_W);
+	}
+	destroy() {
+		this.destroyed = true;
+		this.set(0, 0, 0, 0, 0, 0, 0, 0);
+		clean(this.buffer);
+	}
+};
+var _SHA256 = class extends SHA2_32B {
+	constructor() {
+		super(32, SHA256_IV);
+	}
+};
+const sha256 = createHasher(() => new _SHA256(), oidNist(1));
+//#endregion
+//#region src/internal/client/upload.ts
+const UPLOAD_PART_BYTE_LENGTH = 32 * 1024 * 1024;
+const STATUS_PAGE_LIMIT = 100;
+const STATUS_PAGE_MAXIMUM = 100;
+const ABORT_DEADLINE_MILLISECONDS = 5e3;
+async function uploadFileInternal(runtime, input, controls) {
+	const validated = validateUploadFileInput(input);
+	const totalPartCount = Math.ceil(validated.byteLength / UPLOAD_PART_BYTE_LENGTH);
+	emitProgress(validated.onProgress, "preparing", 0, validated.byteLength, 0, totalPartCount);
+	let session;
+	try {
+		const digests = await hashSource(validated.source, validated.byteLength, totalPartCount, validated.signal);
+		const created = await controls.createUpload({
+			workspaceId: validated.workspaceId,
+			parentItemId: validated.parentItemId,
+			expectedByteLength: validated.byteLength,
+			displayFilename: validated.displayFilename,
+			mediaType: validated.mediaType,
+			callerDeclaredContentDigest: digests.callerDeclaredContentDigest,
+			protectionClassification: validated.protectionClassification,
+			idempotencyKey: validated.idempotencyKey,
+			...validated.signal === void 0 ? {} : { signal: validated.signal }
+		});
+		session = created.data;
+		assertSessionPolicy(session, validated.byteLength, totalPartCount, created.status, created.requestId);
+		const resumed = await readResumeState(controls, validated, session, digests);
+		emitProgress(validated.onProgress, "uploading", resumed.confirmedByteLength, validated.byteLength, resumed.confirmedParts.size, totalPartCount);
+		if (resumed.readyResult) {
+			emitProgress(validated.onProgress, "completing", resumed.confirmedByteLength, validated.byteLength, resumed.confirmedParts.size, totalPartCount);
+			return resumed.readyResult;
+		}
+		let revision = resumed.revision;
+		let confirmedByteLength = resumed.confirmedByteLength;
+		let confirmedPartCount = resumed.confirmedParts.size;
+		if (resumed.lifecycle === "uploading") for (const partNumber of pendingUploadPartNumbers(session.partCount, resumed.confirmedParts)) {
+			const index = partNumber - 1;
+			throwIfCallerAborted(validated.signal);
+			const start = index * session.partByteLength;
+			const end = Math.min(start + session.partByteLength, validated.byteLength);
+			const expectedByteLength = end - start;
+			const checksumSha256 = digests.partChecksums[index];
+			if (!checksumSha256) throw new DriveError("invalid_response");
+			const descriptorResult = await controls.createUploadPartDescriptor({
+				workspaceId: validated.workspaceId,
+				uploadId: session.uploadId,
+				partNumber,
+				checksumSha256,
+				...validated.signal === void 0 ? {} : { signal: validated.signal }
+			});
+			const descriptor = descriptorResult.data;
+			if (descriptor.expectedByteLength !== expectedByteLength || descriptor.expiresAtEpochMilliseconds > session.expiresAtEpochMilliseconds) throw new DriveError("invalid_response", {
+				status: descriptorResult.status,
+				requestId: descriptorResult.requestId
+			});
+			const etag = await putPart(runtime, descriptor, slicePart(validated.source, start, end, expectedByteLength), checksumSha256, validated.signal);
+			revision = await recordPartWithReconciliation(controls, validated, session, partNumber, revision, expectedByteLength, etag, checksumSha256);
+			confirmedByteLength += expectedByteLength;
+			confirmedPartCount += 1;
+			emitProgress(validated.onProgress, "uploading", confirmedByteLength, validated.byteLength, confirmedPartCount, totalPartCount);
+		}
+		emitProgress(validated.onProgress, "completing", confirmedByteLength, validated.byteLength, confirmedPartCount, totalPartCount);
+		return await completeWithReconciliation(controls, validated, session, digests);
+	} catch (error) {
+		if (validated.signal?.aborted && session) await bestEffortAbort(controls, validated.workspaceId, session.uploadId);
+		if (error instanceof DriveError) throw error;
+		throw validated.signal?.aborted ? new DriveError("aborted") : new DriveError("invalid_input");
+	}
+}
+function* pendingUploadPartNumbers(partCount, confirmedParts) {
+	for (let partNumber = 1; partNumber <= partCount; partNumber += 1) if (!confirmedParts.has(partNumber)) yield partNumber;
+}
+async function readResumeState(controls, input, session, digests) {
+	const confirmedParts = new Set();
+	let confirmedByteLength = 0;
+	let afterPartNumber = 0;
+	let baseline;
+	let baselineRequestId;
+	let readyResult;
+	for (let pageNumber = 0; pageNumber < STATUS_PAGE_MAXIMUM; pageNumber += 1) {
+		const result = await controls.getUploadStatus({
+			workspaceId: input.workspaceId,
+			uploadId: session.uploadId,
+			afterPartNumber,
+			limit: STATUS_PAGE_LIMIT,
+			...input.signal === void 0 ? {} : { signal: input.signal }
+		});
+		const status = result.data;
+		assertStatusMatchesSession(status, session);
+		if (baseline) assertSameStatusSnapshot(status, baseline);
+		else {
+			baseline = status;
+			baselineRequestId = result.requestId;
+		}
+		for (const part of status.confirmedParts) {
+			const expectedChecksum = digests.partChecksums[part.partNumber - 1];
+			if (!expectedChecksum || part.checksumSha256 !== expectedChecksum || confirmedParts.has(part.partNumber)) throw new DriveError("invalid_response", {
+				status: result.status,
+				requestId: result.requestId
+			});
+			confirmedParts.add(part.partNumber);
+			confirmedByteLength += expectedPartByteLength(input.byteLength, part.partNumber);
+		}
+		if (status.lifecycle === "ready" && status.ready) {
+			assertReadyMatchesInput(status.ready, session, input, digests, result.requestId);
+			readyResult = resultFromStatus(result, status.ready);
+		}
+		if (status.nextAfterPartNumber === null) break;
+		if (pageNumber === STATUS_PAGE_MAXIMUM - 1) throw new DriveError("invalid_response", {
+			status: result.status,
+			requestId: result.requestId
+		});
+		afterPartNumber = status.nextAfterPartNumber;
+	}
+	if (!baseline) throw new DriveError("invalid_response");
+	if (session.mode === "presigned-multipart" && [
+		"completing",
+		"provider-completed",
+		"ready"
+	].includes(baseline.lifecycle) && confirmedParts.size !== session.partCount) throw new DriveError("invalid_response");
+	failForTerminalStatus(baseline.lifecycle, baselineRequestId);
+	return Object.freeze({
+		revision: baseline.revision,
+		confirmedParts,
+		confirmedByteLength,
+		lifecycle: baseline.lifecycle,
+		...readyResult === void 0 ? {} : { readyResult }
+	});
+}
+async function recordPartWithReconciliation(controls, input, session, partNumber, expectedUploadRevision, byteLength, etag, checksumSha256) {
+	const record = (revision) => controls.recordUploadPart({
+		workspaceId: input.workspaceId,
+		uploadId: session.uploadId,
+		partNumber,
+		expectedUploadRevision: revision,
+		byteLength,
+		etag,
+		checksumSha256,
+		...input.signal === void 0 ? {} : { signal: input.signal }
+	});
+	try {
+		return (await record(expectedUploadRevision)).data.revision;
+	} catch (error) {
+		if (!isAmbiguousControlFailure(error) || input.signal?.aborted) throw error;
+		const statusResult = await controls.getUploadStatus({
+			workspaceId: input.workspaceId,
+			uploadId: session.uploadId,
+			afterPartNumber: partNumber - 1,
+			limit: 1,
+			...input.signal === void 0 ? {} : { signal: input.signal }
+		});
+		const status = statusResult.data;
+		assertStatusMatchesSession(status, session);
+		failForTerminalStatus(status.lifecycle, statusResult.requestId);
+		const confirmed = status.confirmedParts.find((part) => part.partNumber === partNumber);
+		if (confirmed) {
+			if (confirmed.checksumSha256 !== checksumSha256) throw new DriveError("invalid_response", {
+				status: statusResult.status,
+				requestId: statusResult.requestId
+			});
+			return status.revision;
+		}
+		if (status.lifecycle !== "uploading") throw new DriveError("precondition_failed");
+		return (await record(status.revision)).data.revision;
+	}
+}
+async function completeWithReconciliation(controls, input, session, digests) {
+	try {
+		const completed = await controls.completeUpload({
+			workspaceId: input.workspaceId,
+			uploadId: session.uploadId,
+			idempotencyKey: input.completionIdempotencyKey,
+			...input.signal === void 0 ? {} : { signal: input.signal }
+		});
+		assertReadyMatchesInput(completed.data, session, input, digests, completed.requestId);
+		return completed;
+	} catch (error) {
+		if (!isAmbiguousControlFailure(error) || input.signal?.aborted) throw error;
+		const statusResult = await controls.getUploadStatus({
+			workspaceId: input.workspaceId,
+			uploadId: session.uploadId,
+			afterPartNumber: 0,
+			limit: 1,
+			...input.signal === void 0 ? {} : { signal: input.signal }
+		});
+		const status = statusResult.data;
+		assertStatusMatchesSession(status, session);
+		if (status.lifecycle !== "ready" || !status.ready) throw error;
+		assertReadyMatchesInput(status.ready, session, input, digests, statusResult.requestId);
+		return resultFromStatus(statusResult, status.ready);
+	}
+}
+async function hashSource(source, byteLength, partCount, signal) {
+	const fullHash = sha256.create();
+	const partChecksums = [];
+	for (let index = 0; index < partCount; index += 1) {
+		throwIfCallerAborted(signal);
+		const start = index * UPLOAD_PART_BYTE_LENGTH;
+		const end = Math.min(start + UPLOAD_PART_BYTE_LENGTH, byteLength);
+		const part = slicePart(source, start, end, end - start);
+		let buffer;
+		try {
+			buffer = signal ? await raceWithAbort(part.arrayBuffer(), signal) : await part.arrayBuffer();
+		} catch (error) {
+			if (error instanceof DriveError) throw error;
+			throw signal?.aborted ? new DriveError("aborted") : new DriveError("invalid_input");
+		}
+		if (buffer.byteLength !== end - start) throw new DriveError("invalid_input");
+		const bytes = new Uint8Array(buffer);
+		fullHash.update(bytes);
+		partChecksums.push(toBase64(sha256(bytes)));
+	}
+	return Object.freeze({
+		callerDeclaredContentDigest: `sha256:${bytesToHex(fullHash.digest())}`,
+		partChecksums: Object.freeze(partChecksums)
+	});
+}
+async function putPart(runtime, descriptor, part, checksumSha256, callerSignal) {
+	const remainingMilliseconds = descriptor.expiresAtEpochMilliseconds - Date.now();
+	if (remainingMilliseconds < 1) throw new DriveError("invalid_response");
+	const operation = createOperationSignal(callerSignal, Math.min(runtime.timeoutMilliseconds, remainingMilliseconds));
+	let response;
+	try {
+		response = await raceWithAbort(runtime.fetchImplementation(descriptor.url, {
+			method: descriptor.method,
+			body: part,
+			headers: descriptor.headers,
+			credentials: "omit",
+			cache: "no-store",
+			redirect: "error",
+			referrerPolicy: "no-referrer",
+			signal: operation.signal
+		}), operation.signal);
+		if (!(response instanceof Response)) throw new DriveError("invalid_response");
+		const etag = response.headers.get("etag");
+		const responseChecksum = response.headers.get("x-amz-checksum-sha256");
+		if (response.status < 200 || response.status > 299 || !isEtag(etag) || responseChecksum !== checksumSha256) throw new DriveError("invalid_response", { status: response.status });
+		return etag;
+	} catch (error) {
+		if (operation.didTimeout()) throw new DriveError("timeout");
+		if (callerSignal?.aborted) throw new DriveError("aborted");
+		if (error instanceof DriveError) throw error;
+		throw new DriveError("network_error");
+	} finally {
+		operation.dispose();
+		response?.body?.cancel().catch(() => {});
+	}
+}
+function assertSessionPolicy(session, byteLength, partCount, status, requestId) {
+	const expectedMode = byteLength === 0 ? "server-mediated-zero-byte" : "presigned-multipart";
+	if (session.mode !== expectedMode || session.partByteLength !== UPLOAD_PART_BYTE_LENGTH || session.partCount !== partCount || session.expiresAtEpochMilliseconds <= Date.now()) throw new DriveError("invalid_response", {
+		status,
+		requestId
+	});
+}
+function assertStatusMatchesSession(status, session) {
+	if (status.itemId !== session.itemId || status.versionId !== session.versionId || status.uploadId !== session.uploadId || status.mode !== session.mode || status.revision < session.revision || status.partPolicy.partByteLength !== session.partByteLength || status.partPolicy.partCount !== session.partCount || status.partPolicy.maxParts !== 1e4 || status.expiresAtEpochMilliseconds !== session.expiresAtEpochMilliseconds) throw new DriveError("invalid_response");
+}
+function assertSameStatusSnapshot(status, baseline) {
+	if (status.itemId !== baseline.itemId || status.versionId !== baseline.versionId || status.uploadId !== baseline.uploadId || status.mode !== baseline.mode || status.lifecycle !== baseline.lifecycle || status.revision !== baseline.revision || status.partPolicy.partByteLength !== baseline.partPolicy.partByteLength || status.partPolicy.partCount !== baseline.partPolicy.partCount || status.partPolicy.maxParts !== baseline.partPolicy.maxParts || status.expiresAtEpochMilliseconds !== baseline.expiresAtEpochMilliseconds || JSON.stringify(status.ready) !== JSON.stringify(baseline.ready)) throw new DriveError("invalid_response");
+}
+function assertReadyMatchesInput(ready, session, input, digests, requestId) {
+	if (ready.itemId !== session.itemId || ready.versionId !== session.versionId || ready.uploadId !== session.uploadId || ready.byteLength !== input.byteLength || ready.callerDeclaredContentDigest !== digests.callerDeclaredContentDigest || ready.displayFilename !== input.displayFilename || ready.mediaType !== input.mediaType) throw new DriveError("invalid_response", {
+		status: 200,
+		requestId
+	});
+}
+function failForTerminalStatus(lifecycle, requestId) {
+	if (lifecycle === "initiating" || lifecycle === "recovery-required") throw new DriveError("upload_recovery_required", {
+		status: 409,
+		...requestId === void 0 ? {} : { requestId }
+	});
+	if (lifecycle === "aborting" || lifecycle === "aborted") throw new DriveError("precondition_failed", {
+		status: 409,
+		...requestId === void 0 ? {} : { requestId }
+	});
+}
+function resultFromStatus(status, ready) {
+	return Object.freeze({
+		data: ready,
+		status: status.status,
+		requestId: status.requestId,
+		validators: status.validators
+	});
+}
+function expectedPartByteLength(byteLength, partNumber) {
+	return Math.min(UPLOAD_PART_BYTE_LENGTH, byteLength - (partNumber - 1) * UPLOAD_PART_BYTE_LENGTH);
+}
+function slicePart(source, start, end, expectedByteLength) {
+	try {
+		const part = source.slice(start, end);
+		if (!(part instanceof Blob) || part.size !== expectedByteLength) throw new DriveError("invalid_input");
+		return part;
+	} catch (error) {
+		if (error instanceof DriveError) throw error;
+		throw new DriveError("invalid_input");
+	}
+}
+function emitProgress(callback, phase, confirmedByteLength, totalByteLength, confirmedPartCount, totalPartCount) {
+	if (!callback) return;
+	const progress = Object.freeze({
+		phase,
+		confirmedByteLength,
+		totalByteLength,
+		confirmedPartCount,
+		totalPartCount
+	});
+	try {
+		callback(progress);
+	} catch {}
+}
+async function bestEffortAbort(controls, workspaceId, uploadId) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), ABORT_DEADLINE_MILLISECONDS);
+	try {
+		await controls.abortUpload({
+			workspaceId,
+			uploadId,
+			signal: controller.signal
+		});
+	} catch {} finally {
+		clearTimeout(timeout);
+	}
+}
+function isAmbiguousControlFailure(value) {
+	return value instanceof DriveError && (value.code === "network_error" || value.code === "timeout" || value.code === "invalid_response");
+}
+function throwIfCallerAborted(signal) {
+	if (signal?.aborted) throw new DriveError("aborted");
+}
+function toBase64(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+function isEtag(value) {
+	return value !== null && value.length >= 1 && value.length <= 1024 && /^[\x20-\x7e]+$/.test(value);
 }
 //#endregion
 //#region src/client.ts
 function createDriveClient(config) {
-	return createDriveClientInternal(config);
+	const runtime = createClientRuntime(config);
+	const operations = createDriveOperations(runtime);
+	return Object.freeze({
+		...operations,
+		uploadFile: (input) => uploadFileInternal(runtime, input, operations)
+	});
 }
 //#endregion
 export { DRIVE_API_ERROR_CODES, DRIVE_API_ERROR_MESSAGES, DriveError, createDriveClient };