@beam-network/sdk 0.5.0 → 0.5.1

package/dist/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./client.js";
-export * from "./errors.js";
 export * from "./models.js";
 export * from "./provider-signing.js";

package/dist/index.js

@@ -1,4 +1,3 @@
 export * from "./client.js";
-export * from "./errors.js";
 export * from "./models.js";
 export * from "./provider-signing.js";

package/dist/models.d.ts

@@ -1,27 +1,4 @@
 export type SignedUrlFlow = "signed_url_v1" | "signed_url_v2";
-export type CreditVerdict = "unlimited" | "ok" | "low" | "exhausted" | "unknown";
-/**
- * Credit state for the API key that made the request.
- *
- * The verdict is computed server-side and is the single source of truth: never
- * derive one client-side from `remaining` and `low_threshold`, or the SDK will
- * warn at a different point than Beam actually blocks.
- */
-export interface CreditStatus {
-    verdict: CreditVerdict;
-    /** Credits left in the organization pool. Null when unlimited or unknown. */
-    remaining: number | null;
-    /** Balance below which Beam warns. Display only. */
-    low_threshold: number | null;
-    billing_key_id: string | null;
-    billing_org_id: string | null;
-}
-export interface CreditWarning {
-    code: string;
-    message: string;
-    detail?: unknown;
-    credits?: CreditStatus;
-}
 export interface BeamClientOptions {
     apiKey?: string;
     natsUrl?: string;
@@ -33,12 +10,6 @@ export interface BeamClientOptions {
     maxPayloadBytes?: number;
     routeSigningConcurrency?: number;
     fetch?: typeof fetch;
-    /**
-     * Called when Beam reports a credit problem, including once at connect time
-     * from the auth token. Without a handler the SDK logs one line per verdict
-     * change rather than per request.
-     */
-    onCreditWarning?: (warning: CreditWarning) => void;
 }
 export interface SourceConfig {
     type: string;
@@ -99,10 +70,10 @@ export interface RawTransferCreateInput {
     progressiveMode?: boolean;
     signedUrlFlow?: SignedUrlFlow;
     idempotencyKey?: string;
+    /** Internal recovery generation; callers normally leave this unset. */
+    routeGenerationId?: string;
 }
 export interface TransferCreateResponse {
-    /** Credit state after this request. */
-    credits?: CreditStatus;
     success: boolean;
     transfer_id: string;
     transfer_key?: string;
@@ -116,8 +87,6 @@ export interface TransferCreateResponse {
     message?: string;
 }
 export interface TransferCancelResponse {
-    /** Credit state after this request. */
-    credits?: CreditStatus;
     success: boolean;
     message?: string;
 }
@@ -148,8 +117,6 @@ export interface DestinationStatusInfo {
     location?: string;
 }
 export interface TransferStatusInfo {
-    /** Credit state after this request. */
-    credits?: CreditStatus;
     transfer_id: string;
     name?: string;
     status: string;
@@ -180,7 +147,7 @@ export interface TransferStatusInfo {
     };
 }
 export interface TransferTerminalEvent {
-    schema_version: "transfer-client-control/v4";
+    schema_version: "transfer-client-control/v5";
     producer: "transfer-runtime";
     transfer_id: string;
     status: "completed" | "failed" | "cancelled";
@@ -211,23 +178,6 @@ export interface R2ProviderConfig {
     account_id?: string;
     endpoint_url?: string;
 }
-export interface S3CompatibleProviderCapabilities {
-    /**
-     * Whether the provider's ListParts / ListObjects response includes a per-part
-     * LastModified timestamp. Defaults to true (S3-spec compliant). Providers that
-     * omit it (e.g. Hippius) declare false so Beam finalization substitutes a
-     * Beam-side timestamp instead of looping into multipart recovery.
-     */
-    multipart_part_last_modified?: boolean;
-    /**
-     * Per-destination override for Beam Core's assignment-recovery deadline
-     * (TRANSFER_ASSIGNMENT_TIMEOUT_MS), in milliseconds. Omit to use the global
-     * default (15s). Slower providers (e.g. Hippius) declare a larger value so
-     * their assignment waves aren't reassigned prematurely. Only integers >= 1000
-     * are honoured by Beam Core.
-     */
-    assignment_timeout_ms?: number;
-}
 export interface S3CompatibleProviderConfig {
     provider: string;
     driver?: "s3-compatible";
@@ -241,7 +191,6 @@ export interface S3CompatibleProviderConfig {
     session_token?: string;
     force_path_style?: boolean;
     account_id?: string;
-    capabilities?: S3CompatibleProviderCapabilities;
 }
 export interface HippiusProviderConfig {
     provider: "hippius";
@@ -289,6 +238,8 @@ export interface ProviderTransferCreateInput {
     signedUrlFlow?: SignedUrlFlow;
     /** Stable caller identity used to derive the transfer and lifecycle request ids. */
     idempotencyKey?: string;
+    /** Internal recovery generation; callers normally omit this. */
+    routeGenerationId?: string;
 }
 export interface PlanningHttpSource {
     source_id: string;
@@ -385,8 +336,6 @@ export interface MultipartGroupManifest {
     urls_expires_at: string;
 }
 export interface TransferPlanResponse {
-    /** Credit state after this request. */
-    credits?: CreditStatus;
     success: boolean;
     chunk_size?: number;
     total_size?: number;
@@ -396,12 +345,12 @@ export interface TransferPlanResponse {
     total_chunks?: number;
     plan_descriptor: CompactTransferPlanDescriptor;
     signed_url_flow: SignedUrlFlow;
+    plan_fingerprint: string;
+    coordinate_checksum: string;
     error?: string;
     message?: string;
 }
 export interface TransferPrepareResponse {
-    /** Credit state after this request. */
-    credits?: CreditStatus;
     success: boolean;
     transfer_id: string;
     transfer_key?: string;
@@ -414,6 +363,9 @@ export interface TransferPrepareResponse {
     total_chunks?: number;
     plan_descriptor: CompactTransferPlanDescriptor;
     signed_url_flow: SignedUrlFlow;
+    plan_fingerprint: string;
+    coordinate_checksum: string;
+    route_generation_id: string;
     error?: string;
     message?: string;
 }

package/dist/nats-control.d.ts

@@ -1,9 +1,10 @@
-import type { CreditStatus, CreditWarning, MultipartGroupManifest, SignedChunkRoute, TransferTerminalSignalWaiter } from "./models.js";
-export declare const TRANSFER_CLIENT_CONTROL_SCHEMA_VERSION = "transfer-client-control/v4";
+import { type ConnectionOptions } from "nats";
+import type { MultipartGroupManifest, SignedChunkRoute, TransferTerminalSignalWaiter } from "./models.js";
+export declare const TRANSFER_CLIENT_CONTROL_SCHEMA_VERSION = "transfer-client-control/v5";
 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 declare const BEAM_DEFAULT_MAX_PAYLOAD_BYTES: number;
-export type TransferClientMessageType = "transfer.plan" | "transfer.create" | "transfer.prepare" | "transfer.route_stream.begin" | "transfer.route_stream.manifest" | "transfer.route_stream.batch" | "transfer.route_stream.complete" | "transfer.distribute" | "transfer.status" | "transfer.cancel";
+export type TransferClientMessageType = "runtime.hello" | "transfer.plan" | "transfer.create" | "transfer.prepare" | "transfer.route_stream.begin" | "transfer.route_stream.manifest" | "transfer.route_stream.batch" | "transfer.route_stream.complete" | "transfer.distribute" | "transfer.status" | "transfer.cancel" | "transfer.resume";
 export interface CompactSignedRouteBatch {
     source_chunks: Array<{
         source_ref: number;
@@ -28,6 +29,7 @@ export interface CompactSignedRouteBatch {
 }
 export interface RouteStreamBeginPayload {
     transfer_id: string;
+    route_generation_id: string;
     stream_id: string;
     total_routes: number;
     total_chunks: number;
@@ -38,10 +40,16 @@ export interface RouteStreamBeginPayload {
 }
 export interface RouteStreamManifestPayload {
     transfer_id: string;
+    route_generation_id: string;
     stream_id: string;
     manifest_batch_id: string;
     groups: MultipartGroupManifest[];
 }
+export declare function buildConnectionOptions(options: {
+    natsUrl: string;
+    apiKey: string;
+    keyPrefix: string;
+}): ConnectionOptions;
 export interface TransferControlOptions {
     apiKey: string;
     natsUrl?: string;
@@ -51,11 +59,18 @@ export interface TransferControlOptions {
     transferRuntimeShardCount?: number;
     requestTimeoutMs?: number;
     maxPayloadBytes?: number;
-    onCreditWarning?: (warning: CreditWarning) => void;
 }
 export interface LifecycleRequestOptions {
     transferId?: string;
     idempotencyKey?: string;
+    shardId?: number;
+}
+export interface TransferRecoveryLease {
+    transferId: string;
+    planFingerprint: string;
+    coordinateChecksum: string;
+    replayRoutes(routeGenerationId: string): Promise<void>;
+    disposeSecrets?(): void;
 }
 export declare class BeamTransferControl {
     readonly environment: string;
@@ -73,24 +88,24 @@ export declare class BeamTransferControl {
     private authTokenExpiresAt;
     private authResolvePromise;
     private readonly terminalWaitCancellations;
-    private lastCredits;
-    private reportedVerdict;
-    private readonly onCreditWarning;
-    /** Last credit state Beam reported, for display without issuing a request. */
-    get creditStatus(): CreditStatus | null;
-    /**
-     * Records the credit state from a reply or auth token and surfaces a warning.
-     *
-     * Fires on verdict transitions, not per request, so a long-running client does
-     * not emit the same warning on every call.
-     */
-    private observeCredits;
+    private readonly recoveryLeases;
+    private readonly recoveryOperations;
+    private readonly recoveryRequestedEpoch;
+    private readonly runtimeEpochs;
+    private helloTimer;
     constructor(options: TransferControlOptions);
     close(): Promise<void>;
+    registerRecoveryLease(lease: TransferRecoveryLease): () => void;
+    releaseRecoveryLease(transferId: string): void;
+    continueRecoveryLease(transferId: string): void;
     request<T>(messageType: TransferClientMessageType, payload: Record<string, unknown>, options?: LifecycleRequestOptions): Promise<T>;
     openTerminalSignalWaiter(transferId: string): Promise<TransferTerminalSignalWaiter>;
     splitRoutesForPayload(messageType: TransferClientMessageType, basePayload: Record<string, unknown>, routes: SignedChunkRoute[]): SignedChunkRoute[][];
     private connection;
+    private ensureHelloMonitor;
+    private pollRuntimeHello;
+    private observeRuntimeEpoch;
+    private recoverLease;
     private resolveAuthToken;
     private resolveAuthTokenFresh;
     private authSubject;
@@ -99,3 +114,5 @@ export declare class BeamTransferControl {
 }
 export declare function compactSignedRoutes(routes: SignedChunkRoute[]): CompactSignedRouteBatch;
 export declare function transferShardId(transferId: string, shardCount: number): number;
+export declare function isRetryableLifecycleError(error: unknown): boolean;
+export declare function isRecoverableRouteStreamError(error: unknown): boolean;

package/dist/nats-control.js

@@ -1,18 +1,22 @@
 import { encode, decode } from "@msgpack/msgpack";
 import { connect } from "nats";
-import { BeamApiError, BeamInsufficientCreditsError } from "./errors.js";
-export const TRANSFER_CLIENT_CONTROL_SCHEMA_VERSION = "transfer-client-control/v4";
+export const TRANSFER_CLIENT_CONTROL_SCHEMA_VERSION = "transfer-client-control/v5";
 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;
-function buildConnectionOptions(options) {
+export function buildConnectionOptions(options) {
     const connectionOptions = {
         servers: options.natsUrl,
         user: options.keyPrefix,
         pass: options.apiKey,
-        name: `beam-sdk-${options.keyPrefix}`
+        name: `beam-sdk-${options.keyPrefix}`,
+        reconnect: true,
+        maxReconnectAttempts: -1,
+        reconnectTimeWait: 1_000,
+        reconnectJitter: 500,
+        reconnectJitterTLS: 1_000
     };
     if (options.natsUrl.startsWith("tls://")) {
         const tlsOptions = { handshakeFirst: true };
@@ -26,6 +30,14 @@ function buildConnectionOptions(options) {
     }
     return connectionOptions;
 }
+class LifecycleRequestError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "LifecycleRequestError";
+    }
+}
 export class BeamTransferControl {
     environment;
     keyPrefix;
@@ -42,42 +54,11 @@ export class BeamTransferControl {
     authTokenExpiresAt = 0;
     authResolvePromise = null;
     terminalWaitCancellations = new Set();
-    lastCredits = null;
-    reportedVerdict = null;
-    onCreditWarning;
-    /** Last credit state Beam reported, for display without issuing a request. */
-    get creditStatus() {
-        return this.lastCredits;
-    }
-    /**
-     * Records the credit state from a reply or auth token and surfaces a warning.
-     *
-     * Fires on verdict transitions, not per request, so a long-running client does
-     * not emit the same warning on every call.
-     */
-    observeCredits(credits, warnings) {
-        if (!credits)
-            return this.lastCredits;
-        this.lastCredits = credits;
-        if (credits.verdict === this.reportedVerdict)
-            return credits;
-        this.reportedVerdict = credits.verdict;
-        if (credits.verdict !== "low" && credits.verdict !== "exhausted")
-            return credits;
-        const warning = warnings?.[0] ?? {
-            code: credits.verdict === "exhausted" ? "insufficient_credits" : "credits_low",
-            message: credits.remaining === null
-                ? "Beam credit balance is low."
-                : `Beam credit balance is low: ${credits.remaining} credits remaining.`,
-            credits
-        };
-        if (this.onCreditWarning) {
-            this.onCreditWarning({ ...warning, credits });
-            return credits;
-        }
-        console.warn(`[beam] ${warning.message}`);
-        return credits;
-    }
+    recoveryLeases = new Map();
+    recoveryOperations = new Map();
+    recoveryRequestedEpoch = new Map();
+    runtimeEpochs = new Map();
+    helloTimer = null;
     constructor(options) {
         this.apiKey = options.apiKey;
         this.keyPrefix = options.apiKey.slice(0, 12);
@@ -87,7 +68,6 @@ export class BeamTransferControl {
         this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;
         this.maxPayloadBytes = options.maxPayloadBytes ?? BEAM_DEFAULT_MAX_PAYLOAD_BYTES;
         this.natsUrl = options.natsUrl ?? options.natsWsUrl ?? BEAM_DEFAULT_NATS_URL;
-        this.onCreditWarning = options.onCreditWarning;
         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.");
         }
@@ -99,6 +79,13 @@ export class BeamTransferControl {
         this.closed = true;
         for (const cancel of [...this.terminalWaitCancellations])
             cancel();
+        if (this.helloTimer)
+            clearInterval(this.helloTimer);
+        this.helloTimer = null;
+        for (const lease of this.recoveryLeases.values())
+            lease.disposeSecrets?.();
+        this.recoveryLeases.clear();
+        this.recoveryRequestedEpoch.clear();
         if (this.connectionPromise) {
             try {
                 await this.connectionPromise;
@@ -112,9 +99,53 @@ export class BeamTransferControl {
         if (nc && !nc.isClosed())
             await nc.drain();
     }
+    registerRecoveryLease(lease) {
+        if (this.closed)
+            throw new Error("NATS lifecycle control is closed");
+        const previous = this.recoveryLeases.get(lease.transferId);
+        if (previous && previous !== lease)
+            previous.disposeSecrets?.();
+        this.recoveryLeases.set(lease.transferId, lease);
+        this.ensureHelloMonitor();
+        const shardId = transferShardId(lease.transferId, this.shardCount);
+        void this.pollRuntimeHello(shardId);
+        return () => {
+            const current = this.recoveryLeases.get(lease.transferId);
+            if (current !== lease)
+                return;
+            this.recoveryLeases.delete(lease.transferId);
+            this.recoveryRequestedEpoch.delete(lease.transferId);
+            lease.disposeSecrets?.();
+            if (!this.recoveryLeases.size && this.helloTimer) {
+                clearInterval(this.helloTimer);
+                this.helloTimer = null;
+            }
+        };
+    }
+    releaseRecoveryLease(transferId) {
+        const lease = this.recoveryLeases.get(transferId);
+        if (!lease)
+            return;
+        this.recoveryLeases.delete(transferId);
+        this.recoveryRequestedEpoch.delete(transferId);
+        lease.disposeSecrets?.();
+        if (!this.recoveryLeases.size && this.helloTimer) {
+            clearInterval(this.helloTimer);
+            this.helloTimer = null;
+        }
+    }
+    continueRecoveryLease(transferId) {
+        const lease = this.recoveryLeases.get(transferId);
+        if (!lease || this.closed)
+            return;
+        const shardId = transferShardId(transferId, this.shardCount);
+        const epoch = this.runtimeEpochs.get(shardId);
+        this.recoveryRequestedEpoch.set(transferId, epoch ? `${epoch.runtimeEpoch}:${epoch.transportEpoch}` : `foreground:${randomId()}`);
+        void this.recoverLease(lease);
+    }
     async request(messageType, payload, options = {}) {
         const authToken = await this.resolveAuthToken();
-        const shardId = options.transferId ? transferShardId(options.transferId, this.shardCount) : 0;
+        const shardId = options.shardId ?? (options.transferId ? transferShardId(options.transferId, this.shardCount) : 0);
         const requestId = options.idempotencyKey
             ? await stableRequestId(`${messageType}:${options.idempotencyKey}`)
             : randomId();
@@ -142,19 +173,11 @@ export class BeamTransferControl {
                 const nc = await this.connection();
                 const response = await nc.request(subject, bytes, { timeout: this.requestTimeoutMs });
                 const decoded = decode(response.data);
-                const credits = this.observeCredits(decoded.credits, decoded.warnings);
-                if (decoded.ok) {
-                    const payload = (decoded.payload ?? {});
-                    // Credits ride on the envelope, not the payload, so they reach every
-                    // response type without a per-message-type model change.
-                    return (credits ? { ...payload, credits } : payload);
-                }
+                this.observeRuntimeEpoch(shardId, decoded.runtime_epoch, decoded.transport_epoch);
+                if (decoded.ok)
+                    return (decoded.payload ?? {});
                 const body = JSON.stringify(decoded.error ?? {});
-                const code = decoded.error?.code ?? "lifecycle_error";
-                const message = decoded.error?.message ?? body;
-                const error = decoded.status === 402
-                    ? new BeamInsufficientCreditsError(message, code, credits, body)
-                    : new BeamApiError(`Beam lifecycle request failed with ${decoded.status}: ${body}`, decoded.status, body);
+                const error = new LifecycleRequestError(decoded.status, `Beam lifecycle request failed with ${decoded.status}: ${body}`);
                 if (!isRetryableLifecycleStatus(decoded.status) || attempt + 1 >= LIFECYCLE_REQUEST_MAX_ATTEMPTS) {
                     throw error;
                 }
@@ -329,6 +352,96 @@ export class BeamTransferControl {
                 this.connectionPromise = null;
         }
     }
+    ensureHelloMonitor() {
+        if (this.helloTimer || this.closed)
+            return;
+        this.helloTimer = setInterval(() => {
+            const shards = new Set([...this.recoveryLeases.keys()].map((transferId) => transferShardId(transferId, this.shardCount)));
+            for (const shardId of shards)
+                void this.pollRuntimeHello(shardId);
+        }, 5_000);
+        this.helloTimer.unref?.();
+    }
+    async pollRuntimeHello(shardId) {
+        try {
+            await this.request("runtime.hello", {}, { idempotencyKey: `runtime:hello:${shardId}`, shardId });
+        }
+        catch {
+            // Infinite NATS reconnect continues in the background; the next hello reconciles epochs.
+        }
+    }
+    observeRuntimeEpoch(shardId, runtimeEpoch, transportEpoch) {
+        if (!runtimeEpoch || !transportEpoch)
+            return;
+        const previous = this.runtimeEpochs.get(shardId);
+        this.runtimeEpochs.set(shardId, { runtimeEpoch, transportEpoch });
+        if (!previous)
+            return;
+        if (previous.runtimeEpoch === runtimeEpoch && previous.transportEpoch === transportEpoch)
+            return;
+        if (previous.runtimeEpoch !== runtimeEpoch) {
+            this.authToken = null;
+            this.authTokenExpiresAt = 0;
+        }
+        for (const lease of this.recoveryLeases.values()) {
+            if (transferShardId(lease.transferId, this.shardCount) === shardId) {
+                this.recoveryRequestedEpoch.set(lease.transferId, `${runtimeEpoch}:${transportEpoch}`);
+                void this.recoverLease(lease);
+            }
+        }
+    }
+    recoverLease(lease) {
+        const existing = this.recoveryOperations.get(lease.transferId);
+        if (existing)
+            return existing;
+        let operation;
+        operation = (async () => {
+            let attempt = 0;
+            while (!this.closed && this.recoveryLeases.get(lease.transferId) === lease) {
+                const requestedEpoch = this.recoveryRequestedEpoch.get(lease.transferId);
+                const routeGenerationId = randomId();
+                try {
+                    const response = await this.request("transfer.resume", {
+                        transfer_id: lease.transferId,
+                        plan_fingerprint: lease.planFingerprint,
+                        coordinate_checksum: lease.coordinateChecksum,
+                        route_generation_id: routeGenerationId
+                    }, { transferId: lease.transferId, idempotencyKey: `transfer:${lease.transferId}:resume:${routeGenerationId}` });
+                    if (response.recovery === "terminal") {
+                        this.releaseRecoveryLease(lease.transferId);
+                        if (this.recoveryOperations.get(lease.transferId) === operation) {
+                            this.recoveryOperations.delete(lease.transferId);
+                        }
+                        return;
+                    }
+                    if (response.route_replay_required || response.recovery === "route_replay_required") {
+                        await lease.replayRoutes(routeGenerationId);
+                    }
+                    if (this.recoveryRequestedEpoch.get(lease.transferId) !== requestedEpoch) {
+                        attempt = 0;
+                        continue;
+                    }
+                    if (this.recoveryOperations.get(lease.transferId) === operation) {
+                        this.recoveryOperations.delete(lease.transferId);
+                    }
+                    return;
+                }
+                catch (error) {
+                    if (!isRetryableLifecycleError(error)) {
+                        this.releaseRecoveryLease(lease.transferId);
+                        return;
+                    }
+                    attempt += 1;
+                    await sleepWithJitter(Math.min(30_000, 500 * (2 ** Math.min(attempt, 6))));
+                }
+            }
+        })().finally(() => {
+            if (this.recoveryOperations.get(lease.transferId) === operation)
+                this.recoveryOperations.delete(lease.transferId);
+        });
+        this.recoveryOperations.set(lease.transferId, operation);
+        return operation;
+    }
     async resolveAuthToken() {
         const now = Math.floor(Date.now() / 1000);
         if (this.authToken && this.authTokenExpiresAt - 5 > now)
@@ -358,9 +471,6 @@ export class BeamTransferControl {
                 const claims = decodeJwtPayload(parsed.token);
                 this.authToken = parsed.token;
                 this.authTokenExpiresAt = claims.exp;
-                // Pre-flight: the token carries the verdict, so a low balance surfaces
-                // before the first lifecycle request is ever sent.
-                this.observeCredits(claims.credits);
                 return parsed.token;
             }
             catch (error) {
@@ -506,14 +616,22 @@ function randomId() {
     const cryptoApi = globalThis.crypto;
     if (cryptoApi?.randomUUID)
         return cryptoApi.randomUUID();
-    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    if (!cryptoApi?.getRandomValues)
+        throw new Error("secure UUID generation is unavailable");
+    const bytes = cryptoApi.getRandomValues(new Uint8Array(16));
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = [...bytes].map((value) => value.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 const LIFECYCLE_REQUEST_MAX_ATTEMPTS = 3;
 const LIFECYCLE_REQUEST_RETRY_DELAYS_MS = [150, 500];
 function isRetryableLifecycleStatus(status) {
     return status === 408 || status === 425 || status === 429 || status >= 500;
 }
-function isRetryableLifecycleError(error) {
+export function isRetryableLifecycleError(error) {
+    if (error instanceof LifecycleRequestError)
+        return isRetryableLifecycleStatus(error.status);
     const record = error && typeof error === "object" ? error : null;
     const code = typeof record?.code === "string" ? record.code : "";
     const message = error instanceof Error ? error.message : String(error);
@@ -526,10 +644,19 @@ function isRetryableLifecycleError(error) {
         "econnreset",
         "econnrefused",
         "etimedout",
+        "fetch failed",
         "socket",
         "network"
     ].some((token) => combined.includes(token));
 }
+export function isRecoverableRouteStreamError(error) {
+    if (isRetryableLifecycleError(error))
+        return true;
+    if (error instanceof LifecycleRequestError)
+        return error.status === 404 || error.status === 409;
+    const status = error && typeof error === "object" ? Number(error.status) : NaN;
+    return status === 404 || status === 409;
+}
 async function sleepWithJitter(baseMs) {
     const jitter = Math.floor(baseMs * (Math.random() * 0.4 - 0.2));
     await new Promise((resolve) => setTimeout(resolve, Math.max(1, baseMs + jitter)));

package/dist/provider-signing.js

@@ -405,8 +405,7 @@ function s3CompatibleMetadata(source, endpoint = s3CompatibleEndpoint(source)) {
         key: source.key,
         region: s3CompatibleRegion(source),
         endpoint_url: endpoint,
-        account_id: "account_id" in source ? source.account_id : undefined,
-        capabilities: "capabilities" in source ? source.capabilities : undefined
+        account_id: "account_id" in source ? source.account_id : undefined
     });
 }
 function isHippiusProvider(config) {