@lossless.org/client 0.1.0

package/dist_ts/objectstorage/internal.exactupload.operations.js

@@ -0,0 +1,1104 @@
+import * as plugins from './plugins.js';
+import { ExactUploadError } from './classes.exactuploaderror.js';
+import { beginExactUploadCapabilityOperation, beginExactUploadProbeOperation, mintExactUploadCapability, } from './internal.exactupload.capability.js';
+import { planMultipartUpload } from './internal.multipart.planner.js';
+import { consumeExactMultipartStream, MultipartStreamConsumptionError, } from './internal.multipart.stream.js';
+class ExactUploadProbeSemanticError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+        this.name = 'ExactUploadProbeSemanticError';
+    }
+}
+const cleanupTimeoutMs = 30_000;
+const cleanupVerificationMaximumPages = 100;
+const multipartAbortMaximumAttempts = 64;
+const multipartAbortRetryDelayMs = 100;
+const probeMetadata = {
+    'smartbucket-probe': 'exact-upload-v1',
+};
+const snapshotNativeObjectProperties = (valueArg) => {
+    if (valueArg === undefined) {
+        return undefined;
+    }
+    if (valueArg === null
+        || typeof valueArg !== 'object'
+        || Array.isArray(valueArg)) {
+        throw new TypeError('nativeObjectProperties must be an object.');
+    }
+    const keys = Object.keys(valueArg);
+    if (keys.some((keyArg) => keyArg !== 'contentType')) {
+        throw new TypeError('nativeObjectProperties contains an unsupported property.');
+    }
+    if (valueArg.contentType !== undefined
+        && (typeof valueArg.contentType !== 'string'
+            || valueArg.contentType.length === 0
+            || /[\0\r\n]/.test(valueArg.contentType))) {
+        throw new TypeError('nativeObjectProperties.contentType must be a non-empty HTTP header value.');
+    }
+    return Object.freeze({
+        ...(valueArg.contentType === undefined
+            ? {}
+            : { contentType: valueArg.contentType }),
+    });
+};
+const detachedOperationSendSettlements = new WeakMap();
+const trackDetachedOperationSend = (signalArg, settlementArg) => {
+    let settlements = detachedOperationSendSettlements.get(signalArg);
+    if (!settlements) {
+        settlements = new Set();
+        detachedOperationSendSettlements.set(signalArg, settlements);
+    }
+    settlements.add(settlementArg);
+    void settlementArg.then(() => {
+        settlements?.delete(settlementArg);
+        if (settlements?.size === 0) {
+            detachedOperationSendSettlements.delete(signalArg);
+        }
+    });
+};
+const getDetachedOperationSendSettlement = (signalArg) => {
+    const settlements = detachedOperationSendSettlements.get(signalArg);
+    if (!settlements || settlements.size === 0) {
+        return undefined;
+    }
+    return Promise.allSettled([...settlements]).then(() => undefined);
+};
+const finishOperationAfterOwnedSettlements = (operationArg, additionalSettlementsArg = []) => {
+    const detachedSendSettlement = getDetachedOperationSendSettlement(operationArg.signal);
+    const ownedSettlements = detachedSendSettlement
+        ? [detachedSendSettlement, ...additionalSettlementsArg]
+        : additionalSettlementsArg;
+    if (ownedSettlements.length === 0) {
+        operationArg.finish();
+        return;
+    }
+    void Promise.allSettled(ownedSettlements).then(() => {
+        operationArg.finish();
+    });
+};
+const sendOperationCommand = async (operationArg, sendArg) => {
+    operationArg.assertCurrent();
+    const sendOutcome = Promise.resolve()
+        .then(() => {
+        operationArg.assertCurrent();
+        return sendArg(operationArg.signal);
+    })
+        .then((valueArg) => ({
+        status: 'fulfilled',
+        value: valueArg,
+    }), (causeArg) => ({
+        status: 'rejected',
+        cause: causeArg,
+    }));
+    let abortListener;
+    const abortOutcome = new Promise((resolveArg) => {
+        abortListener = () => {
+            resolveArg({
+                status: 'aborted',
+            });
+        };
+        operationArg.signal.addEventListener('abort', abortListener, {
+            once: true,
+        });
+        if (operationArg.signal.aborted) {
+            abortListener();
+        }
+    });
+    const outcome = await Promise.race([sendOutcome, abortOutcome]);
+    if (abortListener) {
+        operationArg.signal.removeEventListener('abort', abortListener);
+    }
+    if (outcome.status === 'aborted') {
+        trackDetachedOperationSend(operationArg.signal, sendOutcome.then(() => undefined));
+        operationArg.assertCurrent();
+        throw new Error('Unreachable exact-upload abort state.');
+    }
+    if (outcome.status === 'rejected') {
+        throw outcome.cause;
+    }
+    operationArg.assertCurrent();
+    return outcome.value;
+};
+const isHttpStatus = (errorArg, statusCodeArg) => {
+    if (typeof errorArg !== 'object' || errorArg === null) {
+        return false;
+    }
+    const metadata = errorArg.$metadata;
+    return metadata?.httpStatusCode === statusCodeArg;
+};
+const isDefinitiveConditionalWriteRejection = (errorArg) => {
+    return isHttpStatus(errorArg, 409) || isHttpStatus(errorArg, 412);
+};
+const requireNonEmptyString = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string' || valueArg.length === 0) {
+        throw new Error(`${fieldNameArg} was not returned by the object provider.`);
+    }
+    return valueArg;
+};
+const getOptionalNonEmptyString = (valueArg) => {
+    return typeof valueArg === 'string' && valueArg.length > 0
+        ? valueArg
+        : undefined;
+};
+const toWebReadableStream = (readableStreamArg) => {
+    if (typeof readableStreamArg === 'object' &&
+        readableStreamArg !== null &&
+        typeof readableStreamArg.getReader ===
+            'function') {
+        return readableStreamArg;
+    }
+    if (readableStreamArg instanceof plugins.stream.Readable) {
+        return plugins.stream.Readable.toWeb(readableStreamArg);
+    }
+    throw new TypeError('readableStream must be a Node.js Readable or a web ReadableStream.');
+};
+const runIndependentCleanup = async (cleanupTasksArg, operationArg) => {
+    const cleanupErrors = [];
+    if (cleanupTasksArg.length === 0) {
+        return {
+            errors: cleanupErrors,
+            timedOut: false,
+            settlement: Promise.resolve(),
+        };
+    }
+    const cleanupAbortController = new AbortController();
+    const cleanupDeadlineToken = Symbol('exact-upload-cleanup-deadline');
+    let resolveCleanupDeadline;
+    const cleanupDeadlineOutcome = new Promise((resolveArg) => {
+        resolveCleanupDeadline = resolveArg;
+    });
+    const cleanupDeadline = setTimeout(() => {
+        const deadlineError = new Error(`Exact-upload cleanup exceeded its ${cleanupTimeoutMs}ms deadline.`);
+        cleanupAbortController.abort(deadlineError);
+        resolveCleanupDeadline(cleanupDeadlineToken);
+    }, cleanupTimeoutMs);
+    let cleanupDeadlineDisposed = false;
+    const disposeCleanupDeadline = () => {
+        if (cleanupDeadlineDisposed) {
+            return;
+        }
+        cleanupDeadlineDisposed = true;
+        clearTimeout(cleanupDeadline);
+    };
+    let releaseOwnedAbort;
+    try {
+        releaseOwnedAbort = operationArg.registerOwnedIndependentAbort(cleanupAbortController, disposeCleanupDeadline);
+    }
+    catch (error) {
+        cleanupAbortController.abort(error);
+        disposeCleanupDeadline();
+        throw error;
+    }
+    const cleanupTaskSequence = Promise.resolve().then(async () => {
+        for (const cleanupTask of cleanupTasksArg) {
+            if (cleanupAbortController.signal.aborted) {
+                break;
+            }
+            try {
+                await cleanupTask(cleanupAbortController.signal);
+            }
+            catch (error) {
+                cleanupErrors.push(error);
+            }
+        }
+    });
+    const normalizedTaskSequence = cleanupTaskSequence.then(() => ({
+        status: 'settled',
+    }), (causeArg) => {
+        cleanupErrors.push(causeArg);
+        return {
+            status: 'settled',
+        };
+    });
+    const settlement = normalizedTaskSequence.then(() => undefined);
+    void settlement.then(() => {
+        releaseOwnedAbort();
+    });
+    try {
+        const outcome = await Promise.race([
+            normalizedTaskSequence,
+            cleanupDeadlineOutcome,
+        ]);
+        if (outcome === cleanupDeadlineToken) {
+            cleanupErrors.push(cleanupAbortController.signal.reason ??
+                new Error('Exact-upload cleanup exceeded its deadline.'));
+            return {
+                errors: cleanupErrors,
+                timedOut: true,
+                settlement,
+            };
+        }
+        return {
+            errors: cleanupErrors,
+            timedOut: false,
+            settlement,
+        };
+    }
+    finally {
+        disposeCleanupDeadline();
+    }
+};
+const assertCleanupActive = (signalArg, assertCurrentArg) => {
+    if (signalArg.aborted) {
+        throw (signalArg.reason ??
+            new Error('Exact-upload cleanup was aborted.'));
+    }
+    assertCurrentArg();
+};
+const sendCleanupRequest = async (signalArg, assertCurrentArg, sendArg) => {
+    assertCleanupActive(signalArg, assertCurrentArg);
+    const output = await sendArg();
+    assertCleanupActive(signalArg, assertCurrentArg);
+    return output;
+};
+const listProbeMultipartUploads = async (clientArg, bucketNameArg, probeRootArg, signalArg, assertCurrentArg) => {
+    const uploads = [];
+    let keyMarker;
+    let uploadIdMarker;
+    for (let pageNumber = 1; pageNumber <= cleanupVerificationMaximumPages; pageNumber++) {
+        const output = await sendCleanupRequest(signalArg, assertCurrentArg, () => clientArg.send(new plugins.s3.ListMultipartUploadsCommand({
+            Bucket: bucketNameArg,
+            Prefix: probeRootArg,
+            KeyMarker: keyMarker,
+            UploadIdMarker: uploadIdMarker,
+        }), {
+            abortSignal: signalArg,
+        }));
+        for (const upload of output.Uploads ?? []) {
+            if (typeof upload.Key !== 'string' ||
+                !upload.Key.startsWith(probeRootArg)) {
+                throw new Error('Multipart cleanup reconciliation returned an invalid prefixed entry.');
+            }
+            if (typeof upload.UploadId !== 'string' ||
+                upload.UploadId.length === 0) {
+                throw new Error(`Probe multipart upload '${upload.Key}' has no UploadId.`);
+            }
+            uploads.push({
+                key: upload.Key,
+                uploadId: upload.UploadId,
+            });
+        }
+        if (!output.IsTruncated) {
+            return uploads;
+        }
+        if (!output.NextKeyMarker ||
+            (output.NextKeyMarker === keyMarker &&
+                output.NextUploadIdMarker === uploadIdMarker)) {
+            throw new Error('Multipart cleanup reconciliation returned a non-advancing page.');
+        }
+        keyMarker = output.NextKeyMarker;
+        uploadIdMarker = output.NextUploadIdMarker;
+    }
+    throw new Error('Multipart cleanup reconciliation exceeded its page bound.');
+};
+const listProbeObjectVersions = async (clientArg, bucketNameArg, probeRootArg, signalArg, assertCurrentArg) => {
+    const versions = [];
+    let keyMarker;
+    let versionIdMarker;
+    for (let pageNumber = 1; pageNumber <= cleanupVerificationMaximumPages; pageNumber++) {
+        const output = await sendCleanupRequest(signalArg, assertCurrentArg, () => clientArg.send(new plugins.s3.ListObjectVersionsCommand({
+            Bucket: bucketNameArg,
+            Prefix: probeRootArg,
+            KeyMarker: keyMarker,
+            VersionIdMarker: versionIdMarker,
+        }), {
+            abortSignal: signalArg,
+        }));
+        for (const version of [
+            ...(output.Versions ?? []),
+            ...(output.DeleteMarkers ?? []),
+        ]) {
+            if (typeof version.Key !== 'string' ||
+                !version.Key.startsWith(probeRootArg)) {
+                throw new Error('Version cleanup reconciliation returned an invalid prefixed entry.');
+            }
+            if (typeof version.VersionId !== 'string' ||
+                version.VersionId.length === 0) {
+                throw new Error(`Probe object version '${version.Key}' has no VersionId.`);
+            }
+            versions.push({
+                key: version.Key,
+                versionId: version.VersionId,
+            });
+        }
+        if (!output.IsTruncated) {
+            return versions;
+        }
+        if (!output.NextKeyMarker ||
+            (output.NextKeyMarker === keyMarker &&
+                output.NextVersionIdMarker === versionIdMarker)) {
+            throw new Error('Version cleanup reconciliation returned a non-advancing page.');
+        }
+        keyMarker = output.NextKeyMarker;
+        versionIdMarker = output.NextVersionIdMarker;
+    }
+    throw new Error('Version cleanup reconciliation exceeded its page bound.');
+};
+const listProbeObjectKeys = async (clientArg, bucketNameArg, probeRootArg, signalArg, assertCurrentArg) => {
+    const keys = [];
+    let continuationToken;
+    for (let pageNumber = 1; pageNumber <= cleanupVerificationMaximumPages; pageNumber++) {
+        const output = await sendCleanupRequest(signalArg, assertCurrentArg, () => clientArg.send(new plugins.s3.ListObjectsV2Command({
+            Bucket: bucketNameArg,
+            Prefix: probeRootArg,
+            ContinuationToken: continuationToken,
+        }), {
+            abortSignal: signalArg,
+        }));
+        for (const object of output.Contents ?? []) {
+            if (typeof object.Key !== 'string' ||
+                !object.Key.startsWith(probeRootArg)) {
+                throw new Error('Object cleanup reconciliation returned an invalid prefixed entry.');
+            }
+            keys.push(object.Key);
+        }
+        if (!output.IsTruncated) {
+            return keys;
+        }
+        if (!output.NextContinuationToken ||
+            output.NextContinuationToken === continuationToken) {
+            throw new Error('Object cleanup reconciliation returned a non-advancing page.');
+        }
+        continuationToken = output.NextContinuationToken;
+    }
+    throw new Error('Object cleanup reconciliation exceeded its page bound.');
+};
+const getHttpStatus = (errorArg) => {
+    if (typeof errorArg !== 'object' || errorArg === null) {
+        return undefined;
+    }
+    const statusCode = errorArg.$metadata?.httpStatusCode;
+    return typeof statusCode === 'number' ? statusCode : undefined;
+};
+const isRetryableCleanupError = (errorArg) => {
+    const statusCode = getHttpStatus(errorArg);
+    return (statusCode === undefined ||
+        statusCode === 409 ||
+        statusCode === 429 ||
+        statusCode >= 500);
+};
+const waitForMultipartAbortRetry = (signalArg) => {
+    return new Promise((resolveArg, rejectArg) => {
+        const retryTimer = setTimeout(() => {
+            signalArg.removeEventListener('abort', abortRetryWait);
+            resolveArg();
+        }, multipartAbortRetryDelayMs);
+        const abortRetryWait = () => {
+            clearTimeout(retryTimer);
+            rejectArg(signalArg.reason ??
+                new Error('Multipart abort reconciliation was aborted.'));
+        };
+        signalArg.addEventListener('abort', abortRetryWait, { once: true });
+        if (signalArg.aborted) {
+            abortRetryWait();
+        }
+    });
+};
+const reconcileMultipartUploadAbort = async (clientArg, bucketNameArg, keyArg, uploadIdArg, signalArg, assertCurrentArg) => {
+    const reconciliationErrors = [];
+    for (let attempt = 1; attempt <= multipartAbortMaximumAttempts; attempt++) {
+        let abortError;
+        let abortRequestSucceeded = false;
+        try {
+            await sendCleanupRequest(signalArg, assertCurrentArg, () => clientArg.send(new plugins.s3.AbortMultipartUploadCommand({
+                Bucket: bucketNameArg,
+                Key: keyArg,
+                UploadId: uploadIdArg,
+            }), {
+                abortSignal: signalArg,
+            }));
+            abortRequestSucceeded = true;
+        }
+        catch (error) {
+            if (isHttpStatus(error, 404)) {
+                return 'absent';
+            }
+            abortError = error;
+            reconciliationErrors.push(error);
+        }
+        try {
+            await sendCleanupRequest(signalArg, assertCurrentArg, () => clientArg.send(new plugins.s3.ListPartsCommand({
+                Bucket: bucketNameArg,
+                Key: keyArg,
+                UploadId: uploadIdArg,
+                MaxParts: 1,
+            }), {
+                abortSignal: signalArg,
+            }));
+        }
+        catch (error) {
+            if (isHttpStatus(error, 404)) {
+                return abortRequestSucceeded ? 'aborted' : 'absent';
+            }
+            reconciliationErrors.push(error);
+            if (!isRetryableCleanupError(error)) {
+                throw new AggregateError(reconciliationErrors, `Multipart upload '${uploadIdArg}' could not be verified as aborted.`);
+            }
+        }
+        if (abortError && !isRetryableCleanupError(abortError)) {
+            throw new AggregateError(reconciliationErrors, `Multipart upload '${uploadIdArg}' could not be aborted.`);
+        }
+        if (attempt === multipartAbortMaximumAttempts) {
+            break;
+        }
+        if (attempt > 3) {
+            await waitForMultipartAbortRetry(signalArg);
+        }
+    }
+    throw new AggregateError(reconciliationErrors, `Multipart upload '${uploadIdArg}' still exists after repeated aborts.`);
+};
+const createProbeCleanupTasks = (clientArg, bucketNameArg, probeRootArg, providerUsesVersionsArg, multipartUploadsArg, objectsArg, assertCurrentArg) => {
+    const cleanupTasks = [];
+    for (const multipartUpload of multipartUploadsArg) {
+        cleanupTasks.push((signalArg) => reconcileMultipartUploadAbort(clientArg, bucketNameArg, multipartUpload.key, multipartUpload.uploadId, signalArg, assertCurrentArg));
+    }
+    for (const object of objectsArg) {
+        cleanupTasks.push((signalArg) => sendCleanupRequest(signalArg, assertCurrentArg, () => clientArg.send(new plugins.s3.DeleteObjectCommand({
+            Bucket: bucketNameArg,
+            Key: object.key,
+            VersionId: object.versionId,
+        }), {
+            abortSignal: signalArg,
+        })));
+    }
+    cleanupTasks.push(async (signalArg) => {
+        const discoveredUploads = await listProbeMultipartUploads(clientArg, bucketNameArg, probeRootArg, signalArg, assertCurrentArg);
+        for (const upload of discoveredUploads) {
+            await reconcileMultipartUploadAbort(clientArg, bucketNameArg, upload.key, upload.uploadId, signalArg, assertCurrentArg);
+        }
+        const remainingUploads = await listProbeMultipartUploads(clientArg, bucketNameArg, probeRootArg, signalArg, assertCurrentArg);
+        if (remainingUploads.length > 0) {
+            throw new Error(`Probe multipart upload '${remainingUploads[0].uploadId}' remains after cleanup.`);
+        }
+    });
+    if (providerUsesVersionsArg) {
+        cleanupTasks.push(async (signalArg) => {
+            const discoveredVersions = await listProbeObjectVersions(clientArg, bucketNameArg, probeRootArg, signalArg, assertCurrentArg);
+            for (const version of discoveredVersions) {
+                await sendCleanupRequest(signalArg, assertCurrentArg, () => clientArg.send(new plugins.s3.DeleteObjectCommand({
+                    Bucket: bucketNameArg,
+                    Key: version.key,
+                    VersionId: version.versionId,
+                }), {
+                    abortSignal: signalArg,
+                }));
+            }
+            const remainingVersions = await listProbeObjectVersions(clientArg, bucketNameArg, probeRootArg, signalArg, assertCurrentArg);
+            if (remainingVersions.length > 0) {
+                throw new Error(`Probe object version '${remainingVersions[0].versionId}' remains after cleanup.`);
+            }
+        });
+    }
+    else {
+        cleanupTasks.push(async (signalArg) => {
+            const discoveredKeys = await listProbeObjectKeys(clientArg, bucketNameArg, probeRootArg, signalArg, assertCurrentArg);
+            for (const key of discoveredKeys) {
+                await sendCleanupRequest(signalArg, assertCurrentArg, () => clientArg.send(new plugins.s3.DeleteObjectCommand({
+                    Bucket: bucketNameArg,
+                    Key: key,
+                }), {
+                    abortSignal: signalArg,
+                }));
+            }
+            const remainingKeys = await listProbeObjectKeys(clientArg, bucketNameArg, probeRootArg, signalArg, assertCurrentArg);
+            if (remainingKeys.length > 0) {
+                throw new Error(`Probe object '${remainingKeys[0]}' remains after cleanup.`);
+            }
+        });
+    }
+    return cleanupTasks;
+};
+export const probeExactUploadCapability = async (bucketRefArg, optionsArg) => {
+    let operation;
+    try {
+        operation = beginExactUploadProbeOperation(bucketRefArg, optionsArg.signal);
+    }
+    catch (error) {
+        return {
+            supported: false,
+            reason: 'unavailable',
+            cause: error,
+        };
+    }
+    const probeRoot = `.smartbucket-probes/exact-upload-v1/${plugins.smartunique.uuid4()}`;
+    const conditionalPutKey = `${probeRoot}/conditional-put`;
+    const conditionalCompleteKey = `${probeRoot}/conditional-complete`;
+    const unfinishedMultipartUploads = [];
+    const probeObjects = [];
+    let providerUsesVersions = false;
+    let failureReason;
+    let failureCause;
+    const recordProbeObject = (keyArg, outputArg) => {
+        const versionId = getOptionalNonEmptyString(outputArg.VersionId);
+        if (versionId) {
+            providerUsesVersions = true;
+        }
+        probeObjects.push({
+            key: keyArg,
+            versionId,
+        });
+    };
+    try {
+        const versioningOutput = await sendOperationCommand(operation, (signalArg) => operation.client.send(new plugins.s3.GetBucketVersioningCommand({
+            Bucket: operation.bucketName,
+        }), {
+            abortSignal: signalArg,
+        }));
+        providerUsesVersions =
+            versioningOutput.Status === 'Enabled' ||
+                versioningOutput.Status === 'Suspended';
+        const firstPutOutput = await sendOperationCommand(operation, (signalArg) => operation.client.send(new plugins.s3.PutObjectCommand({
+            Bucket: operation.bucketName,
+            Key: conditionalPutKey,
+            Body: new Uint8Array(0),
+            ContentLength: 0,
+            Metadata: probeMetadata,
+            IfNoneMatch: '*',
+        }), {
+            abortSignal: signalArg,
+        }));
+        recordProbeObject(conditionalPutKey, firstPutOutput);
+        requireNonEmptyString(firstPutOutput.ETag, 'PutObject ETag');
+        try {
+            const duplicatePutOutput = await sendOperationCommand(operation, (signalArg) => operation.client.send(new plugins.s3.PutObjectCommand({
+                Bucket: operation.bucketName,
+                Key: conditionalPutKey,
+                Body: new Uint8Array(0),
+                ContentLength: 0,
+                Metadata: probeMetadata,
+                IfNoneMatch: '*',
+            }), {
+                abortSignal: signalArg,
+            }));
+            recordProbeObject(conditionalPutKey, duplicatePutOutput);
+            throw new ExactUploadProbeSemanticError('conditional-put-not-enforced');
+        }
+        catch (error) {
+            if (error instanceof ExactUploadProbeSemanticError) {
+                throw error;
+            }
+            operation.assertCurrent();
+            if (!isHttpStatus(error, 412)) {
+                throw error;
+            }
+        }
+        const createFirstOutput = await sendOperationCommand(operation, (signalArg) => operation.client.send(new plugins.s3.CreateMultipartUploadCommand({
+            Bucket: operation.bucketName,
+            Key: conditionalCompleteKey,
+            Metadata: probeMetadata,
+        }), {
+            abortSignal: signalArg,
+        }));
+        const firstUploadId = requireNonEmptyString(createFirstOutput.UploadId, 'CreateMultipartUpload UploadId');
+        unfinishedMultipartUploads.push({
+            key: conditionalCompleteKey,
+            uploadId: firstUploadId,
+        });
+        const firstPartOutput = await sendOperationCommand(operation, (signalArg) => operation.client.send(new plugins.s3.UploadPartCommand({
+            Bucket: operation.bucketName,
+            Key: conditionalCompleteKey,
+            UploadId: firstUploadId,
+            PartNumber: 1,
+            Body: new Uint8Array([1]),
+            ContentLength: 1,
+        }), {
+            abortSignal: signalArg,
+        }));
+        const firstPartEtag = requireNonEmptyString(firstPartOutput.ETag, 'UploadPart ETag');
+        const firstCompleteOutput = await sendOperationCommand(operation, (signalArg) => operation.client.send(new plugins.s3.CompleteMultipartUploadCommand({
+            Bucket: operation.bucketName,
+            Key: conditionalCompleteKey,
+            UploadId: firstUploadId,
+            MultipartUpload: {
+                Parts: [
+                    {
+                        PartNumber: 1,
+                        ETag: firstPartEtag,
+                    },
+                ],
+            },
+            IfNoneMatch: '*',
+            MpuObjectSize: 1,
+        }), {
+            abortSignal: signalArg,
+        }));
+        unfinishedMultipartUploads.splice(unfinishedMultipartUploads.findIndex((uploadArg) => uploadArg.uploadId === firstUploadId), 1);
+        recordProbeObject(conditionalCompleteKey, firstCompleteOutput);
+        requireNonEmptyString(firstCompleteOutput.ETag, 'CompleteMultipartUpload ETag');
+        const createSecondOutput = await sendOperationCommand(operation, (signalArg) => operation.client.send(new plugins.s3.CreateMultipartUploadCommand({
+            Bucket: operation.bucketName,
+            Key: conditionalCompleteKey,
+            Metadata: probeMetadata,
+        }), {
+            abortSignal: signalArg,
+        }));
+        const secondUploadId = requireNonEmptyString(createSecondOutput.UploadId, 'CreateMultipartUpload UploadId');
+        unfinishedMultipartUploads.push({
+            key: conditionalCompleteKey,
+            uploadId: secondUploadId,
+        });
+        const secondPartOutput = await sendOperationCommand(operation, (signalArg) => operation.client.send(new plugins.s3.UploadPartCommand({
+            Bucket: operation.bucketName,
+            Key: conditionalCompleteKey,
+            UploadId: secondUploadId,
+            PartNumber: 1,
+            Body: new Uint8Array([2]),
+            ContentLength: 1,
+        }), {
+            abortSignal: signalArg,
+        }));
+        const secondPartEtag = requireNonEmptyString(secondPartOutput.ETag, 'UploadPart ETag');
+        try {
+            const duplicateCompleteOutput = await sendOperationCommand(operation, (signalArg) => operation.client.send(new plugins.s3.CompleteMultipartUploadCommand({
+                Bucket: operation.bucketName,
+                Key: conditionalCompleteKey,
+                UploadId: secondUploadId,
+                MultipartUpload: {
+                    Parts: [
+                        {
+                            PartNumber: 1,
+                            ETag: secondPartEtag,
+                        },
+                    ],
+                },
+                IfNoneMatch: '*',
+                MpuObjectSize: 1,
+            }), {
+                abortSignal: signalArg,
+            }));
+            unfinishedMultipartUploads.splice(unfinishedMultipartUploads.findIndex((uploadArg) => uploadArg.uploadId === secondUploadId), 1);
+            recordProbeObject(conditionalCompleteKey, duplicateCompleteOutput);
+            throw new ExactUploadProbeSemanticError('conditional-complete-not-enforced');
+        }
+        catch (error) {
+            if (error instanceof ExactUploadProbeSemanticError) {
+                throw error;
+            }
+            operation.assertCurrent();
+            if (!isHttpStatus(error, 412)) {
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof ExactUploadProbeSemanticError) {
+            failureReason = error.reason;
+        }
+        else if (operation.signal.aborted) {
+            failureReason = 'aborted';
+            failureCause = operation.signal.reason;
+        }
+        else {
+            failureReason = 'unavailable';
+            failureCause = error;
+        }
+    }
+    const probeCleanupTasks = createProbeCleanupTasks(operation.client, operation.bucketName, probeRoot, providerUsesVersions, unfinishedMultipartUploads, probeObjects, () => operation.assertLifecycleCurrent());
+    const primaryProviderSettlement = getDetachedOperationSendSettlement(operation.signal);
+    if (primaryProviderSettlement) {
+        const deferredCleanup = primaryProviderSettlement
+            .then(async () => {
+            try {
+                operation.assertLifecycleCurrent();
+                const cleanupResult = await runIndependentCleanup(probeCleanupTasks, operation);
+                await cleanupResult.settlement;
+            }
+            catch {
+                // Lifecycle close makes deferred probe cleanup indeterminate.
+            }
+        })
+            .then(() => undefined, () => undefined);
+        finishOperationAfterOwnedSettlements(operation, [deferredCleanup]);
+        return {
+            supported: false,
+            reason: failureReason ?? 'aborted',
+            cause: failureCause ?? operation.signal.reason,
+        };
+    }
+    const cleanupResult = await runIndependentCleanup(probeCleanupTasks, operation);
+    try {
+        if (cleanupResult.errors.length > 0) {
+            return {
+                supported: false,
+                reason: 'cleanup-failed',
+                cause: new AggregateError(cleanupResult.errors, 'The exact-upload capability probe could not clean up safely.'),
+            };
+        }
+        if (failureReason) {
+            return {
+                supported: false,
+                reason: failureReason,
+                cause: failureCause,
+            };
+        }
+        return {
+            supported: true,
+            capability: mintExactUploadCapability(bucketRefArg, operation),
+        };
+    }
+    catch (error) {
+        return {
+            supported: false,
+            reason: operation.signal.aborted ? 'aborted' : 'unavailable',
+            cause: error,
+        };
+    }
+    finally {
+        if (cleanupResult.timedOut) {
+            finishOperationAfterOwnedSettlements(operation, [
+                cleanupResult.settlement,
+            ]);
+        }
+        else {
+            finishOperationAfterOwnedSettlements(operation);
+        }
+    }
+};
+const abortMultipartUpload = async (operationArg, keyArg, uploadIdArg) => {
+    let reconciliationResult;
+    const cleanupResult = await runIndependentCleanup([
+        async (signalArg) => {
+            reconciliationResult = await reconcileMultipartUploadAbort(operationArg.client, operationArg.bucketName, keyArg, uploadIdArg, signalArg, () => operationArg.assertLifecycleCurrent());
+        },
+    ], operationArg);
+    return {
+        cleanup: cleanupResult.timedOut
+            ? {
+                status: 'deferred',
+            }
+            : cleanupResult.errors.length === 0
+                ? {
+                    status: reconciliationResult ?? 'absent',
+                }
+                : {
+                    status: 'abort-failed',
+                    cause: new AggregateError(cleanupResult.errors, 'The multipart upload could not be aborted safely.'),
+                },
+        timedOut: cleanupResult.timedOut,
+        settlement: cleanupResult.settlement,
+    };
+};
+export const fastPutStreamExact = async (bucketRefArg, optionsArg) => {
+    if (typeof optionsArg.path !== 'string' || optionsArg.path.length === 0) {
+        throw new TypeError('path must be a non-empty string.');
+    }
+    const nativeObjectProperties = snapshotNativeObjectProperties(optionsArg.nativeObjectProperties);
+    const plan = planMultipartUpload({
+        objectSize: optionsArg.contentLength,
+        requestedPartSize: optionsArg.requestedPartSize,
+        requestedConcurrency: optionsArg.requestedConcurrency,
+    });
+    let operation;
+    try {
+        operation = beginExactUploadCapabilityOperation(bucketRefArg, optionsArg.capability, optionsArg.signal);
+    }
+    catch (error) {
+        throw new ExactUploadError({
+            phase: 'capability',
+            destinationPath: optionsArg.path,
+            expectedContentLength: optionsArg.contentLength,
+            destinationPublication: 'not-published',
+            multipartCleanup: {
+                status: 'not-required',
+            },
+        }, error);
+    }
+    let readableStream;
+    try {
+        readableStream = toWebReadableStream(optionsArg.readableStream);
+    }
+    catch (error) {
+        operation.finish();
+        throw new ExactUploadError({
+            phase: 'source',
+            destinationPath: optionsArg.path,
+            expectedContentLength: optionsArg.contentLength,
+            destinationPublication: 'not-published',
+            multipartCleanup: {
+                status: 'not-required',
+            },
+        }, error);
+    }
+    if (plan.classification === 'zero') {
+        let putRequestAttempted = false;
+        let zeroFinishSettlement;
+        try {
+            let consumptionResult;
+            try {
+                consumptionResult = await consumeExactMultipartStream({
+                    readableStream,
+                    plan,
+                    signal: operation.signal,
+                    failureSettlementTimeoutMs: optionsArg.failureSettlementTimeoutMs,
+                    async onPart() {
+                        throw new Error('A zero-byte upload cannot contain multipart parts.');
+                    },
+                });
+            }
+            catch (error) {
+                if (error instanceof MultipartStreamConsumptionError &&
+                    (error.state.cleanup.callbacks === 'detached' ||
+                        error.state.cleanup.reader.status === 'cancel-detached')) {
+                    zeroFinishSettlement = error.ownedSettlement;
+                }
+                throw new ExactUploadError({
+                    phase: 'source',
+                    destinationPath: optionsArg.path,
+                    expectedContentLength: optionsArg.contentLength,
+                    destinationPublication: 'not-published',
+                    multipartCleanup: {
+                        status: 'not-required',
+                    },
+                }, error);
+            }
+            try {
+                const putOutput = await sendOperationCommand(operation, (signalArg) => {
+                    putRequestAttempted = true;
+                    return operation.client.send(new plugins.s3.PutObjectCommand({
+                        Bucket: operation.bucketName,
+                        Key: optionsArg.path,
+                        Body: new Uint8Array(0),
+                        ContentLength: 0,
+                        Metadata: optionsArg.nativeMetadata,
+                        ContentType: nativeObjectProperties?.contentType,
+                        IfNoneMatch: '*',
+                    }), {
+                        abortSignal: signalArg,
+                    });
+                });
+                return {
+                    destinationPath: optionsArg.path,
+                    contentLength: 0,
+                    etag: requireNonEmptyString(putOutput.ETag, 'PutObject ETag'),
+                    versionId: getOptionalNonEmptyString(putOutput.VersionId),
+                    partCount: 0,
+                    peakBufferedBytes: consumptionResult.peakBufferedBytes,
+                    maximumBufferedBytes: consumptionResult.maximumBufferedBytes,
+                };
+            }
+            catch (error) {
+                if (error instanceof ExactUploadError) {
+                    throw error;
+                }
+                throw new ExactUploadError({
+                    phase: 'put-zero',
+                    destinationPath: optionsArg.path,
+                    expectedContentLength: optionsArg.contentLength,
+                    destinationPublication: putRequestAttempted &&
+                        !isDefinitiveConditionalWriteRejection(error)
+                        ? 'ambiguous'
+                        : 'not-published',
+                    multipartCleanup: {
+                        status: 'not-required',
+                    },
+                }, error);
+            }
+        }
+        finally {
+            if (zeroFinishSettlement) {
+                finishOperationAfterOwnedSettlements(operation, [
+                    zeroFinishSettlement,
+                ]);
+            }
+            else {
+                finishOperationAfterOwnedSettlements(operation);
+            }
+        }
+    }
+    let phase = 'create-multipart';
+    let uploadId;
+    let createRequestAttempted = false;
+    let completeRequestAttempted = false;
+    let operationFinishSettlement;
+    let detachedStreamError;
+    try {
+        const createOutput = await sendOperationCommand(operation, (signalArg) => {
+            createRequestAttempted = true;
+            return operation.client.send(new plugins.s3.CreateMultipartUploadCommand({
+                Bucket: operation.bucketName,
+                Key: optionsArg.path,
+                Metadata: optionsArg.nativeMetadata,
+                ContentType: nativeObjectProperties?.contentType,
+            }), {
+                abortSignal: signalArg,
+            });
+        });
+        uploadId = requireNonEmptyString(createOutput.UploadId, 'CreateMultipartUpload UploadId');
+        phase = 'source';
+        const completedParts = [];
+        let consumptionResult;
+        try {
+            consumptionResult = await consumeExactMultipartStream({
+                readableStream,
+                plan,
+                signal: operation.signal,
+                failureSettlementTimeoutMs: optionsArg.failureSettlementTimeoutMs,
+                async onPart(partArg) {
+                    operation.assertCurrent();
+                    const uploadPartOutput = await operation.client.send(new plugins.s3.UploadPartCommand({
+                        Bucket: operation.bucketName,
+                        Key: optionsArg.path,
+                        UploadId: uploadId,
+                        PartNumber: partArg.partNumber,
+                        Body: partArg.data,
+                        ContentLength: partArg.data.byteLength,
+                    }), {
+                        abortSignal: partArg.signal,
+                    });
+                    operation.assertCurrent();
+                    completedParts[partArg.partNumber - 1] = {
+                        PartNumber: partArg.partNumber,
+                        ETag: requireNonEmptyString(uploadPartOutput.ETag, 'UploadPart ETag'),
+                    };
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof MultipartStreamConsumptionError &&
+                error.state.kind === 'part-callback') {
+                phase = 'upload-part';
+            }
+            if (error instanceof MultipartStreamConsumptionError &&
+                (error.state.cleanup.callbacks === 'detached' ||
+                    error.state.cleanup.reader.status === 'cancel-detached')) {
+                detachedStreamError = error;
+            }
+            throw error;
+        }
+        phase = 'complete-multipart';
+        const completeOutput = await sendOperationCommand(operation, (signalArg) => {
+            completeRequestAttempted = true;
+            return operation.client.send(new plugins.s3.CompleteMultipartUploadCommand({
+                Bucket: operation.bucketName,
+                Key: optionsArg.path,
+                UploadId: uploadId,
+                MultipartUpload: {
+                    Parts: completedParts,
+                },
+                IfNoneMatch: '*',
+                MpuObjectSize: optionsArg.contentLength,
+            }), {
+                abortSignal: signalArg,
+            });
+        });
+        return {
+            destinationPath: optionsArg.path,
+            contentLength: optionsArg.contentLength,
+            etag: requireNonEmptyString(completeOutput.ETag, 'CompleteMultipartUpload ETag'),
+            versionId: getOptionalNonEmptyString(completeOutput.VersionId),
+            partCount: completedParts.length,
+            peakBufferedBytes: consumptionResult.peakBufferedBytes,
+            maximumBufferedBytes: consumptionResult.maximumBufferedBytes,
+        };
+    }
+    catch (error) {
+        let multipartCleanup;
+        const primaryProviderSettlement = getDetachedOperationSendSettlement(operation.signal);
+        if (uploadId &&
+            detachedStreamError?.state.cleanup.callbacks === 'detached') {
+            multipartCleanup = {
+                status: 'deferred',
+            };
+            const callbackGatedCleanup = detachedStreamError.callbackSettlement
+                .then(async () => {
+                try {
+                    operation.assertLifecycleCurrent();
+                    const abortResult = await abortMultipartUpload(operation, optionsArg.path, uploadId);
+                    await abortResult.settlement;
+                }
+                catch {
+                    // Lifecycle close makes deferred cleanup indeterminate.
+                }
+            })
+                .then(() => undefined, () => undefined);
+            operationFinishSettlement = Promise.allSettled([
+                callbackGatedCleanup,
+                detachedStreamError.ownedSettlement,
+            ]).then(() => undefined);
+        }
+        else if (uploadId && primaryProviderSettlement) {
+            multipartCleanup = {
+                status: 'deferred',
+            };
+            const providerGatedCleanup = primaryProviderSettlement
+                .then(async () => {
+                try {
+                    operation.assertLifecycleCurrent();
+                    const abortResult = await abortMultipartUpload(operation, optionsArg.path, uploadId);
+                    await abortResult.settlement;
+                }
+                catch {
+                    // Lifecycle close makes deferred cleanup indeterminate.
+                }
+            })
+                .then(() => undefined, () => undefined);
+            operationFinishSettlement = Promise.allSettled([
+                primaryProviderSettlement,
+                providerGatedCleanup,
+            ]).then(() => undefined);
+        }
+        else if (uploadId) {
+            const abortResult = await abortMultipartUpload(operation, optionsArg.path, uploadId);
+            multipartCleanup = abortResult.cleanup;
+            if (abortResult.timedOut) {
+                operationFinishSettlement = abortResult.settlement;
+            }
+        }
+        else if (createRequestAttempted) {
+            multipartCleanup = {
+                ...(primaryProviderSettlement
+                    ? {
+                        status: 'deferred',
+                    }
+                    : {
+                        status: 'abort-failed',
+                        cause: new Error('The multipart upload could not be aborted because no UploadId was returned.'),
+                    }),
+            };
+            if (primaryProviderSettlement) {
+                operationFinishSettlement = primaryProviderSettlement;
+            }
+        }
+        else {
+            multipartCleanup = {
+                status: 'not-required',
+            };
+        }
+        if (detachedStreamError?.state.cleanup.reader.status ===
+            'cancel-detached' &&
+            detachedStreamError.state.cleanup.callbacks !== 'detached') {
+            const ownedSettlements = [
+                detachedStreamError.ownedSettlement,
+            ];
+            if (operationFinishSettlement) {
+                ownedSettlements.push(operationFinishSettlement);
+            }
+            operationFinishSettlement = Promise.allSettled(ownedSettlements).then(() => undefined);
+        }
+        throw new ExactUploadError({
+            phase,
+            destinationPath: optionsArg.path,
+            expectedContentLength: optionsArg.contentLength,
+            destinationPublication: phase === 'complete-multipart' &&
+                completeRequestAttempted &&
+                !isDefinitiveConditionalWriteRejection(error)
+                ? 'ambiguous'
+                : 'not-published',
+            multipartUploadId: uploadId,
+            multipartCleanup,
+        }, error);
+    }
+    finally {
+        if (operationFinishSettlement) {
+            finishOperationAfterOwnedSettlements(operation, [
+                operationFinishSettlement,
+            ]);
+        }
+        else {
+            finishOperationAfterOwnedSettlements(operation);
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"internal.exactupload.operations.js","sourceRoot":"","sources":["../../ts/objectstorage/internal.exactupload.operations.ts"],"names":[],"mappings":"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"}