@beam-network/sdk 0.2.16 → 0.2.18

package/dist/models.d.ts

@@ -50,7 +50,6 @@ export interface TransferCreateRequest {
     chunk_hashes?: string[];
     callbacks?: CallbackConfig[];
     test_mode?: boolean;
-    experimental?: boolean;
     progressive_mode?: boolean;
     signed_url_flow?: SignedUrlFlow;
 }
@@ -67,10 +66,6 @@ export interface RawTransferCreateInput {
      * Maps to BeamCore test_mode.
      */
     testMode?: boolean;
-    /**
-     * Experimental transfers keep positive evidence but exclude failures and overseer interventions from PRISM.
-     */
-    experimental?: boolean;
     progressiveMode?: boolean;
     signedUrlFlow?: SignedUrlFlow;
 }
@@ -78,7 +73,6 @@ export interface TransferCreateResponse {
     success: boolean;
     transfer_id: string;
     transfer_key?: string;
-    experimental?: boolean;
     total_chunks: number;
     total_sources: number;
     total_destinations: number;
@@ -123,7 +117,6 @@ export interface TransferStatusInfo {
     name?: string;
     status: string;
     error_message: string | null;
-    experimental?: boolean;
     started_at: string | null;
     completed_at: string | null;
     total_bytes?: number;
@@ -176,26 +169,6 @@ export interface HippiusProviderConfig {
 }
 export type ProviderConfig = S3ProviderConfig | R2ProviderConfig | S3CompatibleProviderConfig | HippiusProviderConfig;
 export type ProviderSourceConfig = ProviderConfig;
-export interface ChunkChecksumProviderGetInput {
-    source: ProviderSourceConfig;
-    chunk: ChunkSigningPlanItem;
-    algorithm: "content-md5";
-}
-export interface ChunkChecksumProviderSetInput extends ChunkChecksumProviderGetInput {
-    contentMd5: string;
-}
-export interface ChunkChecksumProvider {
-    getContentMd5(input: ChunkChecksumProviderGetInput): Promise<string | null | undefined>;
-    setContentMd5?(input: ChunkChecksumProviderSetInput): Promise<void>;
-}
-export interface ChunkChecksumEvent {
-    event: "checksum_warmup_started" | "checksum_warmup_completed" | "checksum_cache_hit" | "checksum_cache_miss" | "checksum_cold_chunk_cached" | "checksum_cold_group_completed";
-    sourceId: string;
-    sourceChunkIndex?: number;
-    chunkCount?: number;
-    bytes?: number;
-    durationMs?: number;
-}
 export type ProviderDestinationConfig = ProviderConfig;
 export type S3ProviderConfigInput = Omit<S3ProviderConfig, "provider">;
 export type R2ProviderConfigInput = Omit<R2ProviderConfig, "provider">;
@@ -221,25 +194,15 @@ export interface ProviderTransferCreateInput {
      * Maps to BeamCore test_mode.
      */
     testMode?: boolean;
-    /**
-     * Experimental transfers keep positive evidence but exclude failures and overseer interventions from PRISM.
-     */
-    experimental?: boolean;
     expiresIn?: number;
     /**
-     * Defaults to true. Set to false to only prepare and attach signed URLs.
+     * Defaults to true. Set to false to only prepare and stream signed routes without distribution.
      */
     distribute?: boolean;
-    onPlanned?: (plan: TransferPlanResponse) => void | Promise<void>;
     onBeforeTransferPrepare?: () => void | Promise<void>;
     onPrepared?: (prepared: TransferPrepareResponse) => void | Promise<void>;
     throwIfCancelled?: (transferId?: string) => void | Promise<void>;
     signedUrlFlow?: SignedUrlFlow;
-    checksumProvider?: ChunkChecksumProvider;
-    checksumReadConcurrency?: number;
-    checksumGroupSizeBytes?: number;
-    checksumReadTimeoutMs?: number;
-    onChecksumEvent?: (event: ChunkChecksumEvent) => void | Promise<void>;
 }
 export interface PlanningHttpSource {
     source_id: string;
@@ -308,7 +271,6 @@ export interface TransferPrepareResponse {
     transfer_id: string;
     transfer_key?: string;
     test_mode?: boolean;
-    experimental?: boolean;
     chunk_size?: number;
     total_size?: number;
     total_sources?: number;

package/dist/nats-control.d.ts

@@ -1,7 +1,40 @@
 export declare const TRANSFER_CLIENT_CONTROL_SCHEMA_VERSION = "transfer-client-control/v1";
 export declare const BEAM_DEFAULT_NATS_URL = "tls://nats.b1m.ai:4222";
 export declare const BEAM_DEFAULT_NATS_WS_URL = "wss://nats.b1m.ai:443";
-export type TransferClientMessageType = "transfer.plan" | "transfer.create" | "transfer.prepare" | "transfer.attach_signed_urls.begin" | "transfer.attach_signed_urls.chunk" | "transfer.attach_signed_urls.commit" | "transfer.distribute" | "transfer.status" | "transfer.cancel";
+export declare const BEAM_DEFAULT_MAX_PAYLOAD_BYTES: number;
+export declare const ROUTE_RECOVERY_SIGN_MESSAGE_TYPE = "transfer.route_recovery.sign";
+export type TransferClientMessageType = "transfer.plan" | "transfer.create" | "transfer.prepare" | "transfer.route_stream.begin" | "transfer.route_stream.batch" | "transfer.route_stream.complete" | "transfer.distribute" | "transfer.status" | "transfer.cancel";
+export interface RouteRecoverySignChunk {
+    source_id: string;
+    destination_id: string;
+    chunk_index: number;
+    delivery_index: number;
+    source_offset: number;
+    chunk_size: number;
+    logical_attempt_index: number;
+    attempt_slot: 0 | 1 | 2;
+    part_number: number;
+    route_generation_id: string;
+    multipart_group_id: string;
+    final_object_key: string;
+    upload_id?: string;
+    urls_expires_at?: string;
+    multipart_created_at?: string;
+    source_metadata?: Record<string, unknown>;
+    destination_metadata?: Record<string, unknown>;
+}
+export interface RouteRecoverySignRequestPayload {
+    transfer_id: string;
+    route_generation_id: string;
+    requested_at?: string;
+    chunks: RouteRecoverySignChunk[];
+}
+export interface RouteRecoverySignReplyPayload {
+    transfer_id: string;
+    route_generation_id: string;
+    signed_at?: string;
+    chunk_routes: unknown[];
+}
 export interface TransferControlOptions {
     apiKey: string;
     natsUrl?: string;
@@ -25,12 +58,15 @@ export declare class BeamTransferControl {
     private authToken;
     private authTokenExpiresAt;
     constructor(options: TransferControlOptions);
+    serveRouteRecoverySigner(transferId: string, handler: (payload: RouteRecoverySignRequestPayload) => Promise<RouteRecoverySignReplyPayload>): Promise<() => void>;
     close(): Promise<void>;
     request<T>(messageType: TransferClientMessageType, payload: Record<string, unknown>, transferId?: string): Promise<T>;
     splitRoutesForPayload(messageType: TransferClientMessageType, basePayload: Record<string, unknown>, routes: unknown[]): unknown[][];
     private connection;
     private resolveAuthToken;
     private authSubject;
+    private routeRecoverySignSubject;
+    private buildRouteRecoveryReply;
     private requestSubject;
 }
 export declare function transferShardId(transferId: string, shardCount: number): number;

package/dist/nats-control.js

@@ -3,6 +3,29 @@ import { connect } from "nats";
 export const TRANSFER_CLIENT_CONTROL_SCHEMA_VERSION = "transfer-client-control/v1";
 export const BEAM_DEFAULT_NATS_URL = "tls://nats.b1m.ai:4222";
 export const BEAM_DEFAULT_NATS_WS_URL = "wss://nats.b1m.ai:443";
+// NATS enforces max_payload per message. This guard splits signed-route control
+// messages before the broker rejects them; transfer bytes never flow through NATS.
+export const BEAM_DEFAULT_MAX_PAYLOAD_BYTES = 24 * 1024 * 1024;
+export const ROUTE_RECOVERY_SIGN_MESSAGE_TYPE = "transfer.route_recovery.sign";
+function buildConnectionOptions(options) {
+    const connectionOptions = {
+        servers: options.natsUrl,
+        user: options.keyPrefix,
+        pass: options.apiKey,
+        name: `beam-sdk-${options.keyPrefix}`
+    };
+    if (options.natsUrl.startsWith("tls://")) {
+        const tlsOptions = { handshakeFirst: true };
+        try {
+            tlsOptions.servername = new URL(options.natsUrl).hostname;
+        }
+        catch {
+            // URL validation stays with the NATS client; TLS-first is still required.
+        }
+        connectionOptions.tls = tlsOptions;
+    }
+    return connectionOptions;
+}
 export class BeamTransferControl {
     environment;
     keyPrefix;
@@ -22,7 +45,7 @@ export class BeamTransferControl {
         this.subjectPrefix = normalizeSubjectPrefix(options.subjectPrefix ?? "beam.transfer.client");
         this.shardCount = options.transferRuntimeShardCount ?? 1;
         this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;
-        this.maxPayloadBytes = options.maxPayloadBytes ?? 6 * 1024 * 1024;
+        this.maxPayloadBytes = options.maxPayloadBytes ?? BEAM_DEFAULT_MAX_PAYLOAD_BYTES;
         this.natsUrl = options.natsUrl ?? options.natsWsUrl ?? BEAM_DEFAULT_NATS_URL;
         if (/^https?:\/\//i.test(this.natsUrl) || /^wss?:\/\//i.test(this.natsUrl) && !options.natsWsUrl) {
             throw new Error("Beam SDK lifecycle endpoint must be nats://, tls://, or configured as natsWsUrl.");
@@ -31,6 +54,47 @@ export class BeamTransferControl {
             throw new Error("transferRuntimeShardCount must be a positive integer.");
         }
     }
+    async serveRouteRecoverySigner(transferId, handler) {
+        const nc = await this.connection();
+        const subject = this.routeRecoverySignSubject(transferId);
+        const sub = nc.subscribe(subject);
+        let active = true;
+        void (async () => {
+            for await (const msg of sub) {
+                if (!active)
+                    break;
+                let request = null;
+                try {
+                    request = decode(msg.data);
+                    if (request.schema_version !== TRANSFER_CLIENT_CONTROL_SCHEMA_VERSION ||
+                        request.environment !== this.environment ||
+                        request.key_prefix !== this.keyPrefix ||
+                        request.transfer_id !== transferId ||
+                        request.message_type !== ROUTE_RECOVERY_SIGN_MESSAGE_TYPE ||
+                        request.producer !== "transfer-runtime") {
+                        throw new Error("route recovery request envelope mismatch");
+                    }
+                    const payload = await handler(request.payload);
+                    msg.respond(encode(this.buildRouteRecoveryReply(request, true, 200, payload)));
+                }
+                catch (error) {
+                    const fallback = request ?? {
+                        message_id: "unknown",
+                        request_id: "unknown",
+                        transfer_id: transferId
+                    };
+                    msg.respond(encode(this.buildRouteRecoveryReply(fallback, false, 500, undefined, {
+                        code: "route_recovery_sign_failed",
+                        message: error instanceof Error ? error.message : String(error)
+                    })));
+                }
+            }
+        })();
+        return () => {
+            active = false;
+            sub.unsubscribe();
+        };
+    }
     async close() {
         if (!this.nc)
             return;
@@ -100,12 +164,11 @@ export class BeamTransferControl {
     async connection() {
         if (this.nc && !this.nc.isClosed())
             return this.nc;
-        this.nc = await connect({
-            servers: this.natsUrl,
-            user: this.keyPrefix,
-            pass: this.apiKey,
-            name: `beam-sdk-${this.keyPrefix}`
-        });
+        this.nc = await connect(buildConnectionOptions({
+            natsUrl: this.natsUrl,
+            apiKey: this.apiKey,
+            keyPrefix: this.keyPrefix
+        }));
         return this.nc;
     }
     async resolveAuthToken() {
@@ -126,6 +189,26 @@ export class BeamTransferControl {
     authSubject() {
         return `${this.subjectPrefix}.${this.environment}.auth.${this.keyPrefix}.resolve`;
     }
+    routeRecoverySignSubject(transferId) {
+        return `${this.subjectPrefix}.${this.environment}.sdk.${this.keyPrefix}.transfer.${transferId}.route_recovery_sign`;
+    }
+    buildRouteRecoveryReply(request, ok, status, payload, error) {
+        return {
+            message_id: request.message_id,
+            schema_version: TRANSFER_CLIENT_CONTROL_SCHEMA_VERSION,
+            environment: this.environment,
+            key_prefix: this.keyPrefix,
+            transfer_id: request.transfer_id,
+            message_type: ROUTE_RECOVERY_SIGN_MESSAGE_TYPE,
+            request_id: request.request_id,
+            occurred_at: new Date().toISOString(),
+            producer: "sdk",
+            ok,
+            status,
+            ...(payload ? { payload } : {}),
+            ...(error ? { error } : {})
+        };
+    }
     requestSubject(messageType, shardId) {
         return `${this.subjectPrefix}.${this.environment}.sdk.${this.keyPrefix}.shard.${shardId}.${messageType.replace(/\./g, "_")}`;
     }

package/dist/provider-signing.d.ts

@@ -46,7 +46,6 @@ export declare function signDestinationRoute(input: {
     multipartGroupId?: string;
     multipartCreatedAt?: string;
     commitMethod?: "upload_part" | "upload_part_copy";
-    contentMd5?: string;
     partVerifyUrl?: string;
     listPageUrl?: string;
     stagingObjectKey?: string;
@@ -57,21 +56,6 @@ export declare function signDestinationRoute(input: {
     deleteUrl?: string;
     fetchImpl?: typeof fetch;
 }): Promise<SignedChunkRoute>;
-export declare function computeChunksContentMd5(input: {
-    source: ProviderSourceConfig;
-    chunks: ChunkSigningPlanItem[];
-    expiresIn: number;
-    fetchImpl?: typeof fetch;
-    groupSizeBytes?: number;
-    readTimeoutMs?: number;
-}): Promise<Map<number, string>>;
-export declare function computeChunkContentMd5(input: {
-    source: ProviderSourceConfig;
-    chunk: ChunkSigningPlanItem;
-    expiresIn: number;
-    fetchImpl?: typeof fetch;
-    readTimeoutMs?: number;
-}): Promise<string>;
 export declare function isS3CompatibleProvider(config: ProviderSourceConfig | ProviderDestinationConfig): config is AnyS3CompatibleProviderConfig;
 export declare function s3CompatibleEndpoint(source: AnyS3CompatibleProviderConfig): string | undefined;
 export declare function s3CompatibleRegion(source: AnyS3CompatibleProviderConfig): string;

package/dist/provider-signing.js

@@ -1,10 +1,8 @@
-import { createHash } from "node:crypto";
 import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CreateMultipartUploadCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, ListPartsCommand, PutObjectCommand, S3Client, UploadPartCopyCommand, UploadPartCommand } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 export function nowIso() {
     return new Date().toISOString();
 }
-const DEFAULT_CHECKSUM_READ_TIMEOUT_MS = 300_000;
 export function expiresAtIso(expiresIn) {
     return new Date(Date.now() + expiresIn * 1000).toISOString();
 }
@@ -228,7 +226,6 @@ export async function signDestinationRoute(input) {
         partNumber: input.partNumber,
         useStagingPut: input.commitMethod === "upload_part_copy",
         fetchImpl: input.fetchImpl,
-        contentMd5: input.contentMd5
     });
     const sourceRoute = await signSourceRoute({
         source: input.source,
@@ -247,7 +244,6 @@ export async function signDestinationRoute(input) {
         chunk_size: input.chunk.chunk_size,
         expires_at: expiresAtIso(input.expiresIn),
         headers: sourceRoute.headers,
-        ...(input.contentMd5 ? { dest_headers: { "Content-MD5": input.contentMd5 } } : {}),
         metadata: {
             ...(input.target.metadata ?? {}),
             ...(input.transferId ? { transfer_id: input.transferId } : {}),
@@ -262,7 +258,6 @@ export async function signDestinationRoute(input) {
             ...(input.deleteUrl ? { delete_url: input.deleteUrl } : {}),
             ...(input.uploadId ? { upload_id: input.uploadId } : {}),
             ...(input.partNumber ? { part_number: input.partNumber } : {}),
-            ...(input.contentMd5 ? { checksum_algorithm: "content-md5", checksum_value: input.contentMd5 } : {}),
             ...(input.partVerifyUrl ? { part_verify_url: input.partVerifyUrl } : {}),
             ...(input.listPageUrl ? { list_page_url: input.listPageUrl } : {}),
             ...(input.completeUrl ? { complete_url: input.completeUrl } : {}),
@@ -303,27 +298,6 @@ async function signSourceRoute(input) {
     }
     return unsupportedProviderConfig(input.source);
 }
-async function signSourceRangeRoute(input) {
-    const range = rangeHeaderForRange(input.sourceOffset, input.chunkSize);
-    if (isS3CompatibleProvider(input.source)) {
-        const client = createS3CompatibleClient(input.source);
-        return {
-            url: await getSignedUrl(client, new GetObjectCommand({
-                Bucket: input.source.bucket,
-                Key: input.source.key,
-                Range: range
-            }), { expiresIn: input.expiresIn }),
-            headers: { Range: range }
-        };
-    }
-    if (isHippiusProvider(input.source)) {
-        return {
-            url: await hippiusPresign(input.fetchImpl ?? globalThis.fetch, input.source.base_url ?? "https://api.hippius.com", input.source.api_token, input.source.bucket, input.source.key, "get", input.expiresIn),
-            headers: { Range: range }
-        };
-    }
-    return { url: input.fallbackUrl, headers: { Range: range } };
-}
 async function signDestinationUrl(input) {
     if (isS3CompatibleProvider(input.destination)) {
         const client = createS3CompatibleClient(input.destination);
@@ -333,7 +307,6 @@ async function signDestinationUrl(input) {
                 Key: input.uploadPartObjectKey,
                 UploadId: input.uploadId,
                 PartNumber: input.partNumber,
-                ContentMD5: input.contentMd5
             }), { expiresIn: input.expiresIn });
         }
         return getSignedUrl(client, new PutObjectCommand({ Bucket: input.destination.bucket, Key: input.objectKey }), { expiresIn: input.expiresIn });
@@ -343,280 +316,6 @@ async function signDestinationUrl(input) {
     }
     return unsupportedProviderConfig(input.destination);
 }
-export async function computeChunksContentMd5(input) {
-    const output = new Map();
-    const chunks = [...input.chunks].sort((a, b) => a.source_offset - b.source_offset || a.source_chunk_index - b.source_chunk_index);
-    const groups = groupContiguousChunks(chunks, input.groupSizeBytes ?? 256 * 1024 * 1024);
-    for (const group of groups) {
-        const groupOutput = await computeChunkGroupContentMd5Adaptive({
-            source: input.source,
-            chunks: group,
-            expiresIn: input.expiresIn,
-            fetchImpl: input.fetchImpl,
-            readTimeoutMs: input.readTimeoutMs
-        });
-        for (const [sourceChunkIndex, checksum] of groupOutput) {
-            output.set(sourceChunkIndex, checksum);
-        }
-    }
-    return output;
-}
-export async function computeChunkContentMd5(input) {
-    const checksums = await computeChunksContentMd5({
-        source: input.source,
-        chunks: [input.chunk],
-        expiresIn: input.expiresIn,
-        fetchImpl: input.fetchImpl,
-        groupSizeBytes: input.chunk.chunk_size,
-        readTimeoutMs: input.readTimeoutMs
-    });
-    const checksum = checksums.get(input.chunk.source_chunk_index);
-    if (!checksum) {
-        throw new Error(`chunk checksum missing for source chunk ${input.chunk.source_chunk_index}`);
-    }
-    return checksum;
-}
-function groupContiguousChunks(chunks, maxGroupSizeBytes) {
-    const groups = [];
-    let current = [];
-    let groupStart = 0;
-    let groupEnd = 0;
-    const maxBytes = Math.max(1, Math.floor(maxGroupSizeBytes));
-    for (const chunk of chunks) {
-        const chunkStart = Math.max(0, Math.floor(chunk.source_offset));
-        const chunkEnd = chunkStart + Math.max(1, Math.floor(chunk.chunk_size));
-        const startsNewGroup = current.length === 0 ||
-            chunkStart !== groupEnd ||
-            chunkEnd - groupStart > maxBytes;
-        if (startsNewGroup) {
-            if (current.length)
-                groups.push(current);
-            current = [chunk];
-            groupStart = chunkStart;
-            groupEnd = chunkEnd;
-            continue;
-        }
-        current.push(chunk);
-        groupEnd = chunkEnd;
-    }
-    if (current.length)
-        groups.push(current);
-    return groups;
-}
-async function computeChunkGroupContentMd5Adaptive(input) {
-    try {
-        return await retryChecksumRead(() => computeChunkGroupContentMd5(input));
-    }
-    catch (error) {
-        if (input.chunks.length <= 1) {
-            throw error;
-        }
-        const midpoint = Math.ceil(input.chunks.length / 2);
-        const output = new Map();
-        for (const chunks of [input.chunks.slice(0, midpoint), input.chunks.slice(midpoint)]) {
-            const partial = await computeChunkGroupContentMd5Adaptive({ ...input, chunks });
-            for (const [sourceChunkIndex, checksum] of partial) {
-                output.set(sourceChunkIndex, checksum);
-            }
-        }
-        return output;
-    }
-}
-async function computeChunkGroupContentMd5(input) {
-    if (!input.chunks.length)
-        return new Map();
-    const chunks = [...input.chunks].sort((a, b) => a.source_offset - b.source_offset || a.source_chunk_index - b.source_chunk_index);
-    const first = chunks[0];
-    const last = chunks[chunks.length - 1];
-    const sourceOffset = first.source_offset;
-    const totalSize = last.source_offset + last.chunk_size - sourceOffset;
-    return withChecksumReadTimeout(input.readTimeoutMs, async (abortSignal) => {
-        if (isS3CompatibleProvider(input.source)) {
-            const client = createS3CompatibleClient(input.source);
-            const response = await client.send(new GetObjectCommand({
-                Bucket: input.source.bucket,
-                Key: input.source.key,
-                Range: `bytes=${sourceOffset}-${sourceOffset + totalSize - 1}`
-            }), abortSignal ? { abortSignal } : undefined);
-            if (!response.Body) {
-                throw new Error(`chunk checksum read returned no body for ${input.source.bucket}/${input.source.key}`);
-            }
-            return hashChunkGroupContentMd5(chunks, totalSize, bodyToAsyncBytes(response.Body));
-        }
-        const sourceRoute = await signSourceRangeRoute({
-            source: input.source,
-            fallbackUrl: first.source_url,
-            sourceOffset,
-            chunkSize: totalSize,
-            expiresIn: input.expiresIn,
-            fetchImpl: input.fetchImpl
-        });
-        const fetchImpl = input.fetchImpl ?? globalThis.fetch;
-        const response = await fetchImpl(sourceRoute.url, { method: "GET", headers: sourceRoute.headers, signal: abortSignal });
-        if (!response.ok) {
-            const message = `chunk checksum fetch failed with ${response.status}: ${await response.text()}`;
-            throw Object.assign(new Error(message), { status: response.status });
-        }
-        if (response.body) {
-            return hashChunkGroupContentMd5(chunks, totalSize, readableStreamToAsyncBytes(response.body));
-        }
-        return hashChunkGroupContentMd5(chunks, totalSize, [new Uint8Array(await response.arrayBuffer())]);
-    });
-}
-function normalizedChecksumReadTimeoutMs(value) {
-    if (value === undefined)
-        return DEFAULT_CHECKSUM_READ_TIMEOUT_MS;
-    if (!Number.isFinite(value) || value <= 0)
-        return 0;
-    return Math.floor(value);
-}
-async function withChecksumReadTimeout(readTimeoutMs, task) {
-    const timeoutMs = normalizedChecksumReadTimeoutMs(readTimeoutMs);
-    if (timeoutMs <= 0) {
-        return task(undefined);
-    }
-    const controller = new AbortController();
-    const timeoutError = Object.assign(new Error(`chunk checksum read timed out after ${timeoutMs}ms`), { code: "CHECKSUM_READ_TIMEOUT" });
-    let timer;
-    const timeout = new Promise((_resolve, reject) => {
-        timer = setTimeout(() => {
-            controller.abort(timeoutError);
-            reject(timeoutError);
-        }, timeoutMs);
-    });
-    try {
-        return await Promise.race([task(controller.signal), timeout]);
-    }
-    catch (error) {
-        if (controller.signal.aborted) {
-            throw timeoutError;
-        }
-        throw error;
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-async function hashChunkGroupContentMd5(chunks, totalSize, body) {
-    const output = new Map();
-    let chunkIndex = 0;
-    let bytesInChunk = 0;
-    let totalRead = 0;
-    let hash = createHash("md5");
-    const consume = (value) => {
-        let offset = 0;
-        while (offset < value.byteLength) {
-            const chunk = chunks[chunkIndex];
-            if (!chunk) {
-                throw new Error(`chunk checksum fetch size mismatch: read more than ${totalSize} bytes`);
-            }
-            const remainingInChunk = chunk.chunk_size - bytesInChunk;
-            const take = Math.min(remainingInChunk, value.byteLength - offset);
-            hash.update(value.subarray(offset, offset + take));
-            offset += take;
-            totalRead += take;
-            bytesInChunk += take;
-            if (bytesInChunk === chunk.chunk_size) {
-                output.set(chunk.source_chunk_index, hash.digest("base64"));
-                chunkIndex += 1;
-                bytesInChunk = 0;
-                hash = createHash("md5");
-            }
-        }
-    };
-    for await (const value of body) {
-        consume(value);
-    }
-    if (totalRead !== totalSize || output.size !== chunks.length) {
-        throw new Error(`chunk checksum fetch size mismatch: expected ${totalSize}, got ${totalRead}`);
-    }
-    return output;
-}
-async function* readableStreamToAsyncBytes(stream) {
-    const reader = stream.getReader();
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            if (value)
-                yield value;
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-}
-async function* bodyToAsyncBytes(body) {
-    if (body instanceof Uint8Array) {
-        yield body;
-        return;
-    }
-    if (typeof body === "string") {
-        yield new TextEncoder().encode(body);
-        return;
-    }
-    if (body && typeof body.transformToByteArray === "function") {
-        yield new Uint8Array(await body.transformToByteArray());
-        return;
-    }
-    if (body && typeof body.arrayBuffer === "function") {
-        yield new Uint8Array(await body.arrayBuffer());
-        return;
-    }
-    if (body && typeof body.getReader === "function") {
-        yield* readableStreamToAsyncBytes(body);
-        return;
-    }
-    if (body && Symbol.asyncIterator in Object(body)) {
-        for await (const value of body) {
-            yield toUint8Array(value);
-        }
-        return;
-    }
-    throw new Error("provider checksum read returned an unsupported body stream");
-}
-function toUint8Array(value) {
-    if (value instanceof Uint8Array)
-        return value;
-    if (typeof value === "string")
-        return new TextEncoder().encode(value);
-    if (ArrayBuffer.isView(value)) {
-        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    }
-    if (value instanceof ArrayBuffer)
-        return new Uint8Array(value);
-    throw new Error("provider checksum stream yielded an unsupported chunk");
-}
-async function retryChecksumRead(task) {
-    let lastError;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-        try {
-            return await task();
-        }
-        catch (error) {
-            lastError = error;
-            if (isChecksumReadTimeout(error))
-                break;
-            const status = typeof error === "object" && error && "status" in error ? Number(error.status) : undefined;
-            if (status && status >= 400 && status < 500 && status !== 408 && status !== 429)
-                break;
-            if (attempt < 2)
-                await sleep(250 * (attempt + 1));
-        }
-    }
-    throw lastError;
-}
-function isChecksumReadTimeout(error) {
-    return Boolean(error &&
-        typeof error === "object" &&
-        "code" in error &&
-        error.code === "CHECKSUM_READ_TIMEOUT");
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 const s3ClientCache = new Map();
 function s3ClientCacheKey(source, endpoint) {
     return JSON.stringify({