@lossless.org/client 0.1.0

package/ts/objectstorage/internal.exactupload.operations.ts

@@ -0,0 +1,1715 @@
+import * as plugins from './plugins.js';
+import { ExactUploadError } from './classes.exactuploaderror.js';
+import type {
+  IExactUploadCapabilityProbeOptions,
+  IExactUploadResult,
+  IFastPutStreamExactOptions,
+  TExactUploadCapabilityProbeFailureReason,
+  TExactUploadCapabilityProbeResult,
+  TExactUploadFailurePhase,
+  TExactUploadMultipartCleanup,
+} from './interfaces.js';
+import {
+  beginExactUploadCapabilityOperation,
+  beginExactUploadProbeOperation,
+  mintExactUploadCapability,
+  type IExactUploadOperation,
+} from './internal.exactupload.capability.js';
+import { planMultipartUpload } from './internal.multipart.planner.js';
+import {
+  consumeExactMultipartStream,
+  MultipartStreamConsumptionError,
+} from './internal.multipart.stream.js';
+
+interface IExactUploadBucketRef {
+  name: string;
+  smartbucketRef: {
+    readonly storageClient: plugins.s3.S3Client;
+  };
+}
+
+interface IProbeObject {
+  key: string;
+  versionId?: string;
+}
+
+interface IProbeMultipartUpload {
+  key: string;
+  uploadId: string;
+}
+
+interface IIndependentCleanupResult {
+  errors: unknown[];
+  timedOut: boolean;
+  settlement: Promise<void>;
+}
+
+interface IMultipartAbortResult {
+  cleanup: TExactUploadMultipartCleanup;
+  timedOut: boolean;
+  settlement: Promise<void>;
+}
+
+class ExactUploadProbeSemanticError extends Error {
+  constructor(
+    public readonly reason: Extract<
+      TExactUploadCapabilityProbeFailureReason,
+      'conditional-put-not-enforced' | 'conditional-complete-not-enforced'
+    >,
+  ) {
+    super(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: IFastPutStreamExactOptions['nativeObjectProperties'],
+): IFastPutStreamExactOptions['nativeObjectProperties'] => {
+  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<
+  AbortSignal,
+  Set<Promise<void>>
+>();
+
+const trackDetachedOperationSend = (
+  signalArg: AbortSignal,
+  settlementArg: Promise<void>,
+): void => {
+  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: AbortSignal,
+): Promise<void> | undefined => {
+  const settlements = detachedOperationSendSettlements.get(signalArg);
+  if (!settlements || settlements.size === 0) {
+    return undefined;
+  }
+  return Promise.allSettled([...settlements]).then(() => undefined);
+};
+
+const finishOperationAfterOwnedSettlements = (
+  operationArg: IExactUploadOperation,
+  additionalSettlementsArg: Promise<void>[] = [],
+): void => {
+  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 <T>(
+  operationArg: IExactUploadOperation,
+  sendArg: (signalArg: AbortSignal) => Promise<T>,
+): Promise<T> => {
+  operationArg.assertCurrent();
+  const sendOutcome = Promise.resolve()
+    .then(() => {
+      operationArg.assertCurrent();
+      return sendArg(operationArg.signal);
+    })
+    .then<
+      { status: 'fulfilled'; value: T },
+      { status: 'rejected'; cause: unknown }
+    >(
+      (valueArg) => ({
+        status: 'fulfilled',
+        value: valueArg,
+      }),
+      (causeArg: unknown) => ({
+        status: 'rejected',
+        cause: causeArg,
+      }),
+    );
+  let abortListener: (() => void) | undefined;
+  const abortOutcome = new Promise<{ status: 'aborted' }>((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: unknown, statusCodeArg: number): boolean => {
+  if (typeof errorArg !== 'object' || errorArg === null) {
+    return false;
+  }
+  const metadata = (errorArg as {
+    $metadata?: {
+      httpStatusCode?: unknown;
+    };
+  }).$metadata;
+  return metadata?.httpStatusCode === statusCodeArg;
+};
+
+const isDefinitiveConditionalWriteRejection = (
+  errorArg: unknown,
+): boolean => {
+  return isHttpStatus(errorArg, 409) || isHttpStatus(errorArg, 412);
+};
+
+const requireNonEmptyString = (
+  valueArg: unknown,
+  fieldNameArg: string,
+): string => {
+  if (typeof valueArg !== 'string' || valueArg.length === 0) {
+    throw new Error(`${fieldNameArg} was not returned by the object provider.`);
+  }
+  return valueArg;
+};
+
+const getOptionalNonEmptyString = (valueArg: unknown): string | undefined => {
+  return typeof valueArg === 'string' && valueArg.length > 0
+    ? valueArg
+    : undefined;
+};
+
+const toWebReadableStream = (
+  readableStreamArg: plugins.stream.Readable | ReadableStream<Uint8Array>,
+): ReadableStream<Uint8Array> => {
+  if (
+    typeof readableStreamArg === 'object' &&
+    readableStreamArg !== null &&
+    typeof (readableStreamArg as ReadableStream<Uint8Array>).getReader ===
+      'function'
+  ) {
+    return readableStreamArg as ReadableStream<Uint8Array>;
+  }
+  if (readableStreamArg instanceof plugins.stream.Readable) {
+    return plugins.stream.Readable.toWeb(
+      readableStreamArg,
+    ) as ReadableStream<Uint8Array>;
+  }
+  throw new TypeError(
+    'readableStream must be a Node.js Readable or a web ReadableStream.',
+  );
+};
+
+const runIndependentCleanup = async (
+  cleanupTasksArg: Array<(signalArg: AbortSignal) => Promise<unknown>>,
+  operationArg: IExactUploadOperation,
+): Promise<IIndependentCleanupResult> => {
+  const cleanupErrors: unknown[] = [];
+  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!: (
+    valueArg: typeof cleanupDeadlineToken,
+  ) => void;
+  const cleanupDeadlineOutcome = new Promise<typeof cleanupDeadlineToken>(
+    (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 = (): void => {
+    if (cleanupDeadlineDisposed) {
+      return;
+    }
+    cleanupDeadlineDisposed = true;
+    clearTimeout(cleanupDeadline);
+  };
+  let releaseOwnedAbort: () => void;
+  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' },
+    { status: 'settled' }
+  >(
+    () => ({
+      status: 'settled',
+    }),
+    (causeArg: unknown) => {
+      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: AbortSignal,
+  assertCurrentArg: () => void,
+): void => {
+  if (signalArg.aborted) {
+    throw (
+      signalArg.reason ??
+      new Error('Exact-upload cleanup was aborted.')
+    );
+  }
+  assertCurrentArg();
+};
+
+const sendCleanupRequest = async <T>(
+  signalArg: AbortSignal,
+  assertCurrentArg: () => void,
+  sendArg: () => Promise<T>,
+): Promise<T> => {
+  assertCleanupActive(signalArg, assertCurrentArg);
+  const output = await sendArg();
+  assertCleanupActive(signalArg, assertCurrentArg);
+  return output;
+};
+
+const listProbeMultipartUploads = async (
+  clientArg: plugins.s3.S3Client,
+  bucketNameArg: string,
+  probeRootArg: string,
+  signalArg: AbortSignal,
+  assertCurrentArg: () => void,
+): Promise<IProbeMultipartUpload[]> => {
+  const uploads: IProbeMultipartUpload[] = [];
+  let keyMarker: string | undefined;
+  let uploadIdMarker: string | undefined;
+  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: plugins.s3.S3Client,
+  bucketNameArg: string,
+  probeRootArg: string,
+  signalArg: AbortSignal,
+  assertCurrentArg: () => void,
+): Promise<Array<Required<IProbeObject>>> => {
+  const versions: Array<Required<IProbeObject>> = [];
+  let keyMarker: string | undefined;
+  let versionIdMarker: string | undefined;
+  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: plugins.s3.S3Client,
+  bucketNameArg: string,
+  probeRootArg: string,
+  signalArg: AbortSignal,
+  assertCurrentArg: () => void,
+): Promise<string[]> => {
+  const keys: string[] = [];
+  let continuationToken: string | undefined;
+  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: unknown): number | undefined => {
+  if (typeof errorArg !== 'object' || errorArg === null) {
+    return undefined;
+  }
+  const statusCode = (errorArg as {
+    $metadata?: {
+      httpStatusCode?: unknown;
+    };
+  }).$metadata?.httpStatusCode;
+  return typeof statusCode === 'number' ? statusCode : undefined;
+};
+
+const isRetryableCleanupError = (errorArg: unknown): boolean => {
+  const statusCode = getHttpStatus(errorArg);
+  return (
+    statusCode === undefined ||
+    statusCode === 409 ||
+    statusCode === 429 ||
+    statusCode >= 500
+  );
+};
+
+const waitForMultipartAbortRetry = (
+  signalArg: AbortSignal,
+): Promise<void> => {
+  return new Promise<void>((resolveArg, rejectArg) => {
+    const retryTimer = setTimeout(() => {
+      signalArg.removeEventListener('abort', abortRetryWait);
+      resolveArg();
+    }, multipartAbortRetryDelayMs);
+    const abortRetryWait = (): void => {
+      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: plugins.s3.S3Client,
+  bucketNameArg: string,
+  keyArg: string,
+  uploadIdArg: string,
+  signalArg: AbortSignal,
+  assertCurrentArg: () => void,
+): Promise<'aborted' | 'absent'> => {
+  const reconciliationErrors: unknown[] = [];
+  for (
+    let attempt = 1;
+    attempt <= multipartAbortMaximumAttempts;
+    attempt++
+  ) {
+    let abortError: unknown;
+    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: plugins.s3.S3Client,
+  bucketNameArg: string,
+  probeRootArg: string,
+  providerUsesVersionsArg: boolean,
+  multipartUploadsArg: IProbeMultipartUpload[],
+  objectsArg: IProbeObject[],
+  assertCurrentArg: () => void,
+): Array<(signalArg: AbortSignal) => Promise<unknown>> => {
+  const cleanupTasks: Array<
+    (signalArg: AbortSignal) => Promise<unknown>
+  > = [];
+  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: IExactUploadBucketRef,
+  optionsArg: IExactUploadCapabilityProbeOptions,
+): Promise<TExactUploadCapabilityProbeResult> => {
+  let operation: IExactUploadOperation;
+  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: IProbeMultipartUpload[] = [];
+  const probeObjects: IProbeObject[] = [];
+  let providerUsesVersions = false;
+  let failureReason: TExactUploadCapabilityProbeFailureReason | undefined;
+  let failureCause: unknown;
+
+  const recordProbeObject = (
+    keyArg: string,
+    outputArg: {
+      VersionId?: string;
+    },
+  ): void => {
+    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: IExactUploadOperation,
+  keyArg: string,
+  uploadIdArg: string,
+): Promise<IMultipartAbortResult> => {
+  let reconciliationResult: 'aborted' | 'absent' | undefined;
+  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: IExactUploadBucketRef,
+  optionsArg: IFastPutStreamExactOptions,
+): Promise<IExactUploadResult> => {
+  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: IExactUploadOperation;
+  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: ReadableStream<Uint8Array>;
+  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: Promise<void> | undefined;
+    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: TExactUploadFailurePhase = 'create-multipart';
+  let uploadId: string | undefined;
+  let createRequestAttempted = false;
+  let completeRequestAttempted = false;
+  let operationFinishSettlement: Promise<void> | undefined;
+  let detachedStreamError: MultipartStreamConsumptionError | undefined;
+  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: plugins.s3.CompletedPart[] = [];
+    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: TExactUploadMultipartCleanup;
+    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' as const,
+            }
+          : {
+              status: 'abort-failed' as const,
+              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);
+    }
+  }
+};