@qrvey/object-storage 1.0.6-953 → 2.0.0-1158-beta.2

package/dist/cjs/index-v2.js

@@ -0,0 +1,1699 @@
+'use strict';
+
+var exponentialBackoff = require('exponential-backoff');
+var telemetry = require('@qrvey/telemetry');
+var clientS3 = require('@aws-sdk/client-s3');
+var credentialProviders = require('@aws-sdk/credential-providers');
+var nodeHttpHandler = require('@smithy/node-http-handler');
+var https = require('https');
+var crypto = require('crypto');
+var s3RequestPresigner = require('@aws-sdk/s3-request-presigner');
+var libStorage = require('@aws-sdk/lib-storage');
+var stream = require('stream');
+var storageBlob = require('@azure/storage-blob');
+var identity = require('@azure/identity');
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => {
+  if (symbol = Symbol[name])
+    return symbol;
+  throw Error("Symbol." + name + " is not defined");
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  };
+  var method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no));
+  var it = {};
+  return generator = generator.apply(__this, __arguments), it[Symbol.asyncIterator] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")];
+  var isAwait = false;
+  var method;
+  var it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw")
+          throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object))
+            throw TypeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+
+// src/core/errors.ts
+var _StorageError = class _StorageError extends Error {
+  constructor(options) {
+    super(options.message);
+    __publicField(this, "code");
+    __publicField(this, "retryable");
+    __publicField(this, "provider");
+    __publicField(this, "requestId");
+    __publicField(this, "cause");
+    this.name = new.target.name;
+    this.code = options.code;
+    this.retryable = options.retryable;
+    this.provider = options.provider;
+    this.requestId = options.requestId;
+    this.cause = options.cause;
+  }
+};
+__name(_StorageError, "StorageError");
+var StorageError = _StorageError;
+var _ThrottledError = class _ThrottledError extends StorageError {
+  constructor(options) {
+    super(__spreadProps(__spreadValues({
+      code: "THROTTLED"
+    }, options), {
+      retryable: true
+    }));
+    __publicField(this, "retryAfterMs");
+    this.retryAfterMs = options.retryAfterMs;
+  }
+};
+__name(_ThrottledError, "ThrottledError");
+var ThrottledError = _ThrottledError;
+var _NotFoundError = class _NotFoundError extends StorageError {
+  constructor(options) {
+    super(__spreadValues({
+      code: "NOT_FOUND",
+      retryable: false
+    }, options));
+  }
+};
+__name(_NotFoundError, "NotFoundError");
+var NotFoundError = _NotFoundError;
+var _AuthError = class _AuthError extends StorageError {
+  constructor(options) {
+    super(__spreadValues({
+      code: "AUTH",
+      retryable: false
+    }, options));
+  }
+};
+__name(_AuthError, "AuthError");
+var AuthError = _AuthError;
+var _ValidationError = class _ValidationError extends StorageError {
+  constructor(options) {
+    super(__spreadValues({
+      code: "VALIDATION",
+      retryable: false
+    }, options));
+  }
+};
+__name(_ValidationError, "ValidationError");
+var ValidationError = _ValidationError;
+var _ConfigurationError = class _ConfigurationError extends StorageError {
+  constructor(options) {
+    super(__spreadValues({
+      code: "CONFIGURATION",
+      retryable: false
+    }, options));
+  }
+};
+__name(_ConfigurationError, "ConfigurationError");
+var ConfigurationError = _ConfigurationError;
+var _NetworkError = class _NetworkError extends StorageError {
+  constructor(options) {
+    super(__spreadValues({
+      code: "NETWORK",
+      retryable: true
+    }, options));
+  }
+};
+__name(_NetworkError, "NetworkError");
+var NetworkError = _NetworkError;
+var _IntegrityError = class _IntegrityError extends StorageError {
+  constructor(options) {
+    super(__spreadValues({
+      code: "INTEGRITY",
+      retryable: false
+    }, options));
+  }
+};
+__name(_IntegrityError, "IntegrityError");
+var IntegrityError = _IntegrityError;
+var _MultipartSessionError = class _MultipartSessionError extends StorageError {
+  constructor(options) {
+    super(__spreadValues({
+      code: "MULTIPART_SESSION",
+      retryable: false
+    }, options));
+  }
+};
+__name(_MultipartSessionError, "MultipartSessionError");
+var MultipartSessionError = _MultipartSessionError;
+
+// src/core/providerRegistry.ts
+var envDefaults = /* @__PURE__ */ new Map();
+function registerProviderEnvDefaults(providerId, factory) {
+  envDefaults.set(providerId, factory);
+}
+__name(registerProviderEnvDefaults, "registerProviderEnvDefaults");
+function resolveOptionsFromEnv(env = process.env) {
+  var _a3, _b;
+  const providerId = (_a3 = env.OBJECT_STORAGE_SERVICE) == null ? void 0 : _a3.toLowerCase();
+  const factory = providerId ? envDefaults.get(providerId) : void 0;
+  if (!factory) {
+    throw new ConfigurationError({
+      message: `Unsupported or missing OBJECT_STORAGE_SERVICE: "${(_b = env.OBJECT_STORAGE_SERVICE) != null ? _b : ""}". Registered providers: ${[
+        ...envDefaults.keys()
+      ].join(", ")}`
+    });
+  }
+  return factory(env);
+}
+__name(resolveOptionsFromEnv, "resolveOptionsFromEnv");
+function resolveObjectStorageOptions(options, env = process.env) {
+  return options != null ? options : resolveOptionsFromEnv(env);
+}
+__name(resolveObjectStorageOptions, "resolveObjectStorageOptions");
+var logger = new telemetry.LoggerService("@qrvey/object-storage");
+
+// src/core/instrumentation.ts
+function recordRetry(code) {
+  logger.warn("objectstorage.retry", {
+    code: code != null ? code : "unknown"
+  });
+}
+__name(recordRetry, "recordRetry");
+function recordThrottle(provider) {
+  logger.warn("objectstorage.throttle", {
+    provider: provider != null ? provider : "unknown"
+  });
+}
+__name(recordThrottle, "recordThrottle");
+async function instrument(provider, operation, fn) {
+  const startedAt = Date.now();
+  try {
+    const result = await fn();
+    logger.debug("objectstorage.operation", {
+      provider,
+      operation,
+      result: "ok",
+      durationMs: Date.now() - startedAt
+    });
+    return result;
+  } catch (error) {
+    const meta = {
+      provider,
+      operation,
+      result: "error",
+      durationMs: Date.now() - startedAt
+    };
+    if (error instanceof StorageError) {
+      meta.code = error.code;
+      meta.retryable = error.retryable;
+      if (error.requestId)
+        meta.requestId = error.requestId;
+    }
+    logger.error("objectstorage.operation", meta);
+    throw error;
+  }
+}
+__name(instrument, "instrument");
+
+// src/core/retry.ts
+var DEFAULTS = {
+  numOfAttempts: 5,
+  startingDelayMs: 100,
+  maxDelayMs: 5e3
+};
+function isRetryableError(error) {
+  return error instanceof StorageError && error.retryable;
+}
+__name(isRetryableError, "isRetryableError");
+async function withRetry(fn, policy = {}) {
+  var _a3;
+  const { numOfAttempts, startingDelayMs, maxDelayMs } = __spreadValues(__spreadValues({}, DEFAULTS), policy);
+  const shouldRetry = (_a3 = policy.retry) != null ? _a3 : isRetryableError;
+  const options = {
+    numOfAttempts,
+    startingDelay: startingDelayMs,
+    maxDelay: maxDelayMs,
+    jitter: "full",
+    retry: async (error, attempt) => {
+      if (!shouldRetry(error, attempt))
+        return false;
+      const code = error instanceof StorageError ? error.code : void 0;
+      recordRetry(code);
+      if (error instanceof ThrottledError) {
+        recordThrottle(error.provider);
+      }
+      logger.warn("object-storage operation retry", {
+        attempt,
+        numOfAttempts,
+        code
+      });
+      if (error instanceof ThrottledError && error.retryAfterMs !== void 0) {
+        await sleep(Math.min(error.retryAfterMs, maxDelayMs));
+      }
+      return true;
+    }
+  };
+  return exponentialBackoff.backOff(fn, options);
+}
+__name(withRetry, "withRetry");
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(sleep, "sleep");
+
+// src/core/concurrency.ts
+function createLimiter(options) {
+  var _a3, _b;
+  const ceiling = options.max;
+  const floor = (_a3 = options.minMax) != null ? _a3 : 1;
+  const growthThreshold = (_b = options.growthThreshold) != null ? _b : 10;
+  let max = options.max;
+  let inFlight = 0;
+  let consecutiveSuccesses = 0;
+  const queue = [];
+  function release() {
+    var _a4;
+    inFlight--;
+    (_a4 = queue.shift()) == null ? void 0 : _a4();
+  }
+  __name(release, "release");
+  function acquire() {
+    if (inFlight < max) {
+      inFlight++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => queue.push(() => {
+      inFlight++;
+      resolve();
+    }));
+  }
+  __name(acquire, "acquire");
+  function onThrottle() {
+    if (!options.adaptive)
+      return;
+    consecutiveSuccesses = 0;
+    const reduced = Math.max(floor, Math.floor(max / 2));
+    if (reduced < max) {
+      max = reduced;
+      logger.warn("object-storage limiter shrunk after throttle", {
+        max
+      });
+    }
+  }
+  __name(onThrottle, "onThrottle");
+  function onSuccess() {
+    if (!options.adaptive || max >= ceiling)
+      return;
+    consecutiveSuccesses++;
+    if (consecutiveSuccesses >= growthThreshold) {
+      consecutiveSuccesses = 0;
+      max = Math.min(ceiling, max + 1);
+    }
+  }
+  __name(onSuccess, "onSuccess");
+  return {
+    async run(fn) {
+      await acquire();
+      try {
+        const result = await fn();
+        onSuccess();
+        return result;
+      } catch (error) {
+        if (error instanceof ThrottledError)
+          onThrottle();
+        throw error;
+      } finally {
+        release();
+      }
+    },
+    get inFlight() {
+      return inFlight;
+    },
+    get pending() {
+      return queue.length;
+    },
+    get currentMax() {
+      return max;
+    }
+  };
+}
+__name(createLimiter, "createLimiter");
+
+// src/core/batch.ts
+function chunk(items, size) {
+  const chunks = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+}
+__name(chunk, "chunk");
+async function mapBatched(items, batchSize, limiter, fn) {
+  const batches = chunk(items, batchSize);
+  return Promise.all(batches.map((batch, index) => limiter.run(() => fn(batch, index))));
+}
+__name(mapBatched, "mapBatched");
+
+// src/core/range.ts
+var BOUNDED = /^bytes=(\d+)-(\d+)?$/;
+var SUFFIX = /^bytes=-(\d+)$/;
+function parseRange(input) {
+  const bounded = BOUNDED.exec(input);
+  if (bounded && bounded[1] !== void 0) {
+    const start = Number(bounded[1]);
+    const end = bounded[2] !== void 0 ? Number(bounded[2]) : void 0;
+    if (end !== void 0 && end < start) {
+      throw new ValidationError({
+        message: `Invalid range "${input}": end must be >= start`
+      });
+    }
+    return {
+      start,
+      end
+    };
+  }
+  const suffix = SUFFIX.exec(input);
+  if (suffix && suffix[1] !== void 0) {
+    return {
+      suffixLength: Number(suffix[1])
+    };
+  }
+  throw new ValidationError({
+    message: `Invalid range "${input}": expected "bytes=start-[end]" or "bytes=-suffix"`
+  });
+}
+__name(parseRange, "parseRange");
+function toRangeHeader(range) {
+  var _a3;
+  if (range.suffixLength !== void 0)
+    return `bytes=-${range.suffixLength}`;
+  return `bytes=${range.start}-${(_a3 = range.end) != null ? _a3 : ""}`;
+}
+__name(toRangeHeader, "toRangeHeader");
+
+// src/providers/aws-s3/config.ts
+var AWS_S3_PROVIDER_ID = "aws_s3";
+function isAwsS3StorageOptions(options) {
+  return options.provider === AWS_S3_PROVIDER_ID;
+}
+__name(isAwsS3StorageOptions, "isAwsS3StorageOptions");
+function getDefaultAwsS3OptionsFromEnv(env = process.env) {
+  const region = env.AWS_REGION || env.AWS_DEFAULT_REGION;
+  if (!region) {
+    throw new ConfigurationError({
+      provider: AWS_S3_PROVIDER_ID,
+      message: "Missing AWS_REGION (or AWS_DEFAULT_REGION) for aws_s3 provider"
+    });
+  }
+  return {
+    provider: AWS_S3_PROVIDER_ID,
+    region,
+    auth: {
+      kind: "default"
+    }
+  };
+}
+__name(getDefaultAwsS3OptionsFromEnv, "getDefaultAwsS3OptionsFromEnv");
+registerProviderEnvDefaults(AWS_S3_PROVIDER_ID, getDefaultAwsS3OptionsFromEnv);
+
+// src/core/clientCache.ts
+var DEFAULT_MAX_SIZE = 32;
+var _ClientCache = class _ClientCache {
+  constructor(options = {}) {
+    __publicField(this, "options");
+    __publicField(this, "entries");
+    this.options = options;
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  getOrCreate(key, factory) {
+    var _a3, _b, _c;
+    const existing = this.entries.get(key);
+    if (existing !== void 0) {
+      this.entries.delete(key);
+      this.entries.set(key, existing);
+      return existing;
+    }
+    const client = factory();
+    this.entries.set(key, client);
+    logger.debug("object-storage client created", {
+      size: this.entries.size
+    });
+    const maxSize = (_a3 = this.options.maxSize) != null ? _a3 : DEFAULT_MAX_SIZE;
+    if (this.entries.size > maxSize) {
+      const oldestKey = this.entries.keys().next().value;
+      const oldest = this.entries.get(oldestKey);
+      this.entries.delete(oldestKey);
+      (_c = (_b = this.options).onEvict) == null ? void 0 : _c.call(_b, oldest, oldestKey);
+      logger.warn("object-storage client evicted from cache", {
+        maxSize
+      });
+    }
+    return client;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+__name(_ClientCache, "ClientCache");
+var ClientCache = _ClientCache;
+function stableCacheKey(parts) {
+  return JSON.stringify(sortDeep(parts));
+}
+__name(stableCacheKey, "stableCacheKey");
+function hashSecret(value) {
+  return crypto.createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+__name(hashSecret, "hashSecret");
+function sortDeep(value) {
+  if (Array.isArray(value))
+    return value.map(sortDeep);
+  if (value && typeof value === "object") {
+    return Object.keys(value).sort().reduce((acc, key) => {
+      acc[key] = sortDeep(value[key]);
+      return acc;
+    }, {});
+  }
+  return value;
+}
+__name(sortDeep, "sortDeep");
+
+// src/providers/aws-s3/clientFactory.ts
+var DEFAULT_HTTP = {
+  connectionTimeoutMs: 5e3,
+  requestTimeoutMs: 12e4,
+  maxSockets: 64
+};
+var cache = new ClientCache({
+  onEvict: (client) => client.destroy()
+});
+function getAwsS3Client(options) {
+  var _a3;
+  const auth = (_a3 = options.auth) != null ? _a3 : {
+    kind: "default"
+  };
+  const key = stableCacheKey({
+    provider: options.provider,
+    region: options.region,
+    endpoint: options.endpoint,
+    http: options.http,
+    auth: authKeyParts(auth)
+  });
+  return cache.getOrCreate(key, () => buildClient(options, auth));
+}
+__name(getAwsS3Client, "getAwsS3Client");
+function clearAwsS3ClientCache() {
+  cache.clear();
+}
+__name(clearAwsS3ClientCache, "clearAwsS3ClientCache");
+function buildClient(options, auth) {
+  const http = __spreadValues(__spreadValues({}, DEFAULT_HTTP), options.http);
+  return new clientS3.S3Client({
+    region: options.region,
+    endpoint: options.endpoint,
+    credentials: credentialsFor(auth),
+    requestHandler: new nodeHttpHandler.NodeHttpHandler({
+      connectionTimeout: http.connectionTimeoutMs,
+      requestTimeout: http.requestTimeoutMs,
+      httpsAgent: new https.Agent({
+        keepAlive: true,
+        maxSockets: http.maxSockets
+      })
+    })
+  });
+}
+__name(buildClient, "buildClient");
+function credentialsFor(auth) {
+  switch (auth.kind) {
+    case "default":
+      return credentialProviders.fromNodeProviderChain();
+    case "static":
+      return auth.credentials;
+    case "assumeRole":
+      return credentialProviders.fromTemporaryCredentials({
+        params: {
+          RoleArn: auth.roleArn,
+          ExternalId: auth.externalId,
+          RoleSessionName: "qrvey-object-storage"
+        }
+      });
+    case "webIdentity":
+      return credentialProviders.fromTokenFile(__spreadValues({
+        roleArn: auth.roleArn
+      }, auth.tokenFile && {
+        webIdentityTokenFile: auth.tokenFile
+      }));
+  }
+}
+__name(credentialsFor, "credentialsFor");
+function authKeyParts(auth) {
+  switch (auth.kind) {
+    case "default":
+      return {
+        kind: auth.kind
+      };
+    case "static":
+      return {
+        kind: auth.kind,
+        accessKeyId: auth.credentials.accessKeyId,
+        secret: hashSecret(auth.credentials.secretAccessKey)
+      };
+    case "assumeRole":
+      return {
+        kind: auth.kind,
+        roleArn: auth.roleArn,
+        externalId: auth.externalId
+      };
+    case "webIdentity":
+      return {
+        kind: auth.kind,
+        roleArn: auth.roleArn,
+        tokenFile: auth.tokenFile
+      };
+  }
+}
+__name(authKeyParts, "authKeyParts");
+
+// src/providers/aws-s3/errors.ts
+var THROTTLE_NAMES = /* @__PURE__ */ new Set([
+  "SlowDown",
+  "ThrottlingException",
+  "Throttling",
+  "TooManyRequestsException",
+  "RequestLimitExceeded",
+  "ProvisionedThroughputExceededException"
+]);
+var NOT_FOUND_NAMES = /* @__PURE__ */ new Set([
+  "NoSuchKey",
+  "NoSuchBucket",
+  "NotFound",
+  "NoSuchUpload"
+]);
+var AUTH_NAMES = /* @__PURE__ */ new Set([
+  "AccessDenied",
+  "InvalidAccessKeyId",
+  "SignatureDoesNotMatch",
+  "ExpiredToken",
+  "TokenRefreshRequired",
+  "CredentialsProviderError"
+]);
+function mapAwsError(error) {
+  var _a3, _b, _c, _d, _e, _f;
+  if (error instanceof StorageError)
+    return error;
+  const aws = error != null ? error : {};
+  const name = (_a3 = aws.name) != null ? _a3 : "UnknownError";
+  const message = (_b = aws.message) != null ? _b : String(error);
+  const status = (_c = aws.$metadata) == null ? void 0 : _c.httpStatusCode;
+  const base = {
+    message: `${name}: ${message}`,
+    provider: AWS_S3_PROVIDER_ID,
+    requestId: (_d = aws.$metadata) == null ? void 0 : _d.requestId,
+    cause: error
+  };
+  if (THROTTLE_NAMES.has(name) || status === 429) {
+    const retryAfter = (_f = (_e = aws.$response) == null ? void 0 : _e.headers) == null ? void 0 : _f["retry-after"];
+    return new ThrottledError(__spreadProps(__spreadValues({}, base), {
+      code: name,
+      retryAfterMs: retryAfter !== void 0 ? Number(retryAfter) * 1e3 : void 0
+    }));
+  }
+  if (NOT_FOUND_NAMES.has(name) || status === 404) {
+    return new NotFoundError(__spreadProps(__spreadValues({}, base), {
+      code: name
+    }));
+  }
+  if (AUTH_NAMES.has(name) || status === 403) {
+    return new AuthError(__spreadProps(__spreadValues({}, base), {
+      code: name
+    }));
+  }
+  if (status !== void 0 && status >= 500 || name === "TimeoutError") {
+    return new NetworkError(__spreadProps(__spreadValues({}, base), {
+      code: name
+    }));
+  }
+  return new StorageError(__spreadProps(__spreadValues({}, base), {
+    code: name,
+    retryable: false
+  }));
+}
+__name(mapAwsError, "mapAwsError");
+var DELETE_BATCH_SIZE = 1e3;
+var DEFAULT_PRESIGN_SECONDS = 3600;
+var _AwsS3Provider = class _AwsS3Provider {
+  constructor(config) {
+    __publicField(this, "bucketName");
+    __publicField(this, "multipart");
+    __publicField(this, "client");
+    __publicField(this, "retryPolicy");
+    __publicField(this, "limiter");
+    var _a3, _b;
+    const resolved = resolveObjectStorageOptions(config.options);
+    if (!isAwsS3StorageOptions(resolved)) {
+      throw new ConfigurationError({
+        message: `AwsS3Provider requires aws_s3 options, got provider "${resolved.provider}"`
+      });
+    }
+    this.bucketName = config.bucketName;
+    this.client = getAwsS3Client(resolved);
+    this.retryPolicy = (_a3 = config.retry) != null ? _a3 : {};
+    this.limiter = (_b = config.limiter) != null ? _b : createLimiter({
+      max: 10,
+      adaptive: true
+    });
+    this.multipart = new AwsS3MultipartClient(this.client, this.bucketName, this.retryPolicy, (operation, fn) => this.send(operation, fn));
+  }
+  send(operation, fn) {
+    return instrument(AWS_S3_PROVIDER_ID, operation, () => withRetry(() => fn().catch((error) => Promise.reject(mapAwsError(error))), this.retryPolicy));
+  }
+  async getObject(key, options) {
+    const range = (options == null ? void 0 : options.range) ? toRangeHeader(parseRange(options.range)) : void 0;
+    const response = await this.send("getObject", () => this.client.send(new clientS3.GetObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Range: range,
+      VersionId: options == null ? void 0 : options.versionId
+    })));
+    return {
+      body: response.Body,
+      contentLength: response.ContentLength,
+      contentType: response.ContentType,
+      contentEncoding: response.ContentEncoding,
+      contentDisposition: response.ContentDisposition,
+      contentLanguage: response.ContentLanguage,
+      cacheControl: response.CacheControl,
+      etag: response.ETag,
+      lastModified: response.LastModified,
+      metadata: response.Metadata
+    };
+  }
+  async getObjectProperties(key) {
+    const response = await this.send("getObjectProperties", () => this.client.send(new clientS3.HeadObjectCommand({
+      Bucket: this.bucketName,
+      Key: key
+    })));
+    return {
+      contentLength: response.ContentLength,
+      contentType: response.ContentType,
+      etag: response.ETag,
+      lastModified: response.LastModified,
+      metadata: response.Metadata
+    };
+  }
+  async upload(key, body, options) {
+    if (body instanceof stream.Readable) {
+      return this.uploadStream(key, body, options);
+    }
+    const response = await this.send("upload", () => this.client.send(new clientS3.PutObjectCommand(__spreadValues({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: body
+    }, mapUploadOptions(options)))));
+    return {
+      key,
+      etag: response.ETag,
+      versionId: response.VersionId
+    };
+  }
+  async uploadStream(key, body, options) {
+    var _a3, _b;
+    const upload = new libStorage.Upload({
+      client: this.client,
+      params: __spreadValues({
+        Bucket: this.bucketName,
+        Key: key,
+        Body: body
+      }, mapUploadOptions(options)),
+      queueSize: (_a3 = options == null ? void 0 : options.queueSize) != null ? _a3 : 5,
+      partSize: (_b = options == null ? void 0 : options.partSizeBytes) != null ? _b : 8 * 1024 * 1024
+    });
+    return instrument(AWS_S3_PROVIDER_ID, "upload", async () => {
+      try {
+        const response = await upload.done();
+        return {
+          key,
+          etag: response.ETag,
+          versionId: response.VersionId
+        };
+      } catch (error) {
+        throw mapAwsError(error);
+      }
+    });
+  }
+  createWriteStream(key, options) {
+    var _a3, _b;
+    const stream$1 = new stream.PassThrough();
+    const upload = new libStorage.Upload({
+      client: this.client,
+      params: __spreadValues({
+        Bucket: this.bucketName,
+        Key: key,
+        Body: stream$1
+      }, mapUploadOptions(options)),
+      queueSize: (_a3 = options == null ? void 0 : options.queueSize) != null ? _a3 : 5,
+      partSize: (_b = options == null ? void 0 : options.partSizeBytes) != null ? _b : 8 * 1024 * 1024
+    });
+    const done = instrument(AWS_S3_PROVIDER_ID, "createWriteStream", () => upload.done().then((response) => ({
+      key,
+      etag: response.ETag,
+      versionId: response.VersionId
+    })).catch((error) => Promise.reject(mapAwsError(error))));
+    return {
+      stream: stream$1,
+      done,
+      abort: () => upload.abort()
+    };
+  }
+  async delete(key) {
+    await this.send("delete", () => this.client.send(new clientS3.DeleteObjectCommand({
+      Bucket: this.bucketName,
+      Key: key
+    })));
+  }
+  async deleteMany(keys) {
+    const batchResults = await mapBatched(keys, DELETE_BATCH_SIZE, this.limiter, async (batch) => {
+      var _a3;
+      const response = await this.send("deleteMany", () => this.client.send(new clientS3.DeleteObjectsCommand({
+        Bucket: this.bucketName,
+        Delete: {
+          Objects: batch.map((key) => ({
+            Key: key
+          })),
+          Quiet: false
+        }
+      })));
+      const failed = new Map(((_a3 = response.Errors) != null ? _a3 : []).map((e) => {
+        var _a4, _b;
+        return [
+          (_a4 = e.Key) != null ? _a4 : "",
+          (_b = e.Message) != null ? _b : "delete failed"
+        ];
+      }));
+      return batch.map((key) => ({
+        key,
+        deleted: !failed.has(key),
+        error: failed.get(key)
+      }));
+    });
+    return batchResults.flat();
+  }
+  async list(options) {
+    var _a3;
+    const response = await this.send("list", () => this.client.send(new clientS3.ListObjectsV2Command({
+      Bucket: this.bucketName,
+      Prefix: options == null ? void 0 : options.prefix,
+      MaxKeys: options == null ? void 0 : options.limit,
+      ContinuationToken: options == null ? void 0 : options.continuationToken
+    })));
+    return {
+      items: ((_a3 = response.Contents) != null ? _a3 : []).map(toObjectSummary),
+      nextToken: response.NextContinuationToken
+    };
+  }
+  iterate(options) {
+    return __asyncGenerator(this, null, function* () {
+      let token;
+      do {
+        const page = yield new __await(this.list({
+          prefix: options == null ? void 0 : options.prefix,
+          limit: options == null ? void 0 : options.pageSize,
+          continuationToken: token
+        }));
+        yield* __yieldStar(page.items);
+        token = page.nextToken;
+      } while (token);
+    });
+  }
+  async listAll(options) {
+    const items = [];
+    try {
+      for (var iter = __forAwait(this.iterate(options)), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+        const item = temp.value;
+        items.push(item);
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+    return items;
+  }
+  async headBucket() {
+    try {
+      await this.send("headBucket", () => this.client.send(new clientS3.HeadBucketCommand({
+        Bucket: this.bucketName
+      })));
+      return {
+        exists: true
+      };
+    } catch (error) {
+      if (error instanceof NotFoundError)
+        return {
+          exists: false
+        };
+      throw error;
+    }
+  }
+  getDownloadUrl(key, options) {
+    var _a3;
+    return s3RequestPresigner.getSignedUrl(this.client, new clientS3.GetObjectCommand({
+      Bucket: this.bucketName,
+      Key: key
+    }), {
+      expiresIn: (_a3 = options == null ? void 0 : options.expiresInSeconds) != null ? _a3 : DEFAULT_PRESIGN_SECONDS
+    });
+  }
+  async getUploadUrl(key, options) {
+    var _a3;
+    const url = await s3RequestPresigner.getSignedUrl(this.client, new clientS3.PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      ContentType: options == null ? void 0 : options.contentType
+    }), {
+      expiresIn: (_a3 = options == null ? void 0 : options.expiresInSeconds) != null ? _a3 : DEFAULT_PRESIGN_SECONDS
+    });
+    return {
+      key,
+      url
+    };
+  }
+};
+__name(_AwsS3Provider, "AwsS3Provider");
+var AwsS3Provider = _AwsS3Provider;
+var _a;
+var AwsS3MultipartClient = (_a = class {
+  constructor(client, bucketName, retryPolicy, send) {
+    __publicField(this, "client");
+    __publicField(this, "bucketName");
+    __publicField(this, "retryPolicy");
+    __publicField(this, "send");
+    this.client = client;
+    this.bucketName = bucketName;
+    this.retryPolicy = retryPolicy;
+    this.send = send;
+  }
+  async create(key, options) {
+    const response = await this.send("multipart.create", () => this.client.send(new clientS3.CreateMultipartUploadCommand(__spreadValues({
+      Bucket: this.bucketName,
+      Key: key
+    }, mapUploadOptions(options)))));
+    return {
+      uploadId: response.UploadId
+    };
+  }
+  async uploadPart(key, uploadId, partNumber, body, contentLengthBytes) {
+    const response = await this.send("multipart.uploadPart", () => this.client.send(new clientS3.UploadPartCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      UploadId: uploadId,
+      PartNumber: partNumber,
+      Body: body,
+      ContentLength: contentLengthBytes
+    })));
+    return {
+      partNumber,
+      etag: response.ETag
+    };
+  }
+  getPartUploadUrl(key, uploadId, partNumber, options) {
+    var _a3;
+    return s3RequestPresigner.getSignedUrl(this.client, new clientS3.UploadPartCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      UploadId: uploadId,
+      PartNumber: partNumber
+    }), {
+      expiresIn: (_a3 = options == null ? void 0 : options.expiresInSeconds) != null ? _a3 : DEFAULT_PRESIGN_SECONDS
+    });
+  }
+  async complete(key, uploadId, parts) {
+    const response = await this.send("multipart.complete", () => this.client.send(new clientS3.CompleteMultipartUploadCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      UploadId: uploadId,
+      MultipartUpload: {
+        Parts: [
+          ...parts
+        ].sort((a, b) => a.partNumber - b.partNumber).map((p) => ({
+          PartNumber: p.partNumber,
+          ETag: p.etag
+        }))
+      }
+    })));
+    return {
+      key,
+      etag: response.ETag,
+      versionId: response.VersionId
+    };
+  }
+  async abort(key, uploadId) {
+    await this.send("multipart.abort", () => this.client.send(new clientS3.AbortMultipartUploadCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      UploadId: uploadId
+    })));
+  }
+  async listParts(key, uploadId) {
+    var _a3;
+    const response = await this.send("multipart.listParts", () => this.client.send(new clientS3.ListPartsCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      UploadId: uploadId
+    })));
+    return ((_a3 = response.Parts) != null ? _a3 : []).map((p) => ({
+      partNumber: p.PartNumber,
+      etag: p.ETag,
+      size: p.Size,
+      lastModified: p.LastModified
+    }));
+  }
+  async listUploads(prefix) {
+    var _a3;
+    const response = await this.send("multipart.listUploads", () => this.client.send(new clientS3.ListMultipartUploadsCommand({
+      Bucket: this.bucketName,
+      Prefix: prefix
+    })));
+    return ((_a3 = response.Uploads) != null ? _a3 : []).map((u) => ({
+      key: u.Key,
+      uploadId: u.UploadId,
+      initiatedAt: u.Initiated
+    }));
+  }
+}, __name(_a, "AwsS3MultipartClient"), _a);
+function mapUploadOptions(options) {
+  return {
+    ContentType: options == null ? void 0 : options.contentType,
+    ContentEncoding: options == null ? void 0 : options.contentEncoding,
+    CacheControl: options == null ? void 0 : options.cacheControl,
+    ContentDisposition: options == null ? void 0 : options.contentDisposition,
+    Metadata: options == null ? void 0 : options.metadata
+  };
+}
+__name(mapUploadOptions, "mapUploadOptions");
+function toObjectSummary(content) {
+  return {
+    key: content.Key,
+    size: content.Size,
+    etag: content.ETag,
+    lastModified: content.LastModified
+  };
+}
+__name(toObjectSummary, "toObjectSummary");
+
+// src/providers/azure-blob/config.ts
+var AZURE_BLOB_PROVIDER_ID = "azure_blob_storage";
+function isAzureBlobStorageOptions(options) {
+  return options.provider === AZURE_BLOB_PROVIDER_ID;
+}
+__name(isAzureBlobStorageOptions, "isAzureBlobStorageOptions");
+function getDefaultAzureBlobOptionsFromEnv(env = process.env) {
+  const connectionString = env.AZURE_DATALAKE_CONNECTION_STRING || env.AZURE_STORAGE_CONNECTION_STRING;
+  if (!connectionString) {
+    throw new ConfigurationError({
+      provider: AZURE_BLOB_PROVIDER_ID,
+      message: "Missing AZURE_DATALAKE_CONNECTION_STRING (or AZURE_STORAGE_CONNECTION_STRING) for azure_blob_storage provider"
+    });
+  }
+  return {
+    provider: AZURE_BLOB_PROVIDER_ID,
+    auth: {
+      kind: "connectionString",
+      connectionString
+    }
+  };
+}
+__name(getDefaultAzureBlobOptionsFromEnv, "getDefaultAzureBlobOptionsFromEnv");
+registerProviderEnvDefaults(AZURE_BLOB_PROVIDER_ID, getDefaultAzureBlobOptionsFromEnv);
+var cache2 = new ClientCache();
+function getAzureBlobServiceClient(options) {
+  const key = stableCacheKey({
+    provider: options.provider,
+    endpoint: options.endpoint,
+    auth: authKeyParts2(options.auth)
+  });
+  return cache2.getOrCreate(key, () => buildClient2(options));
+}
+__name(getAzureBlobServiceClient, "getAzureBlobServiceClient");
+function clearAzureBlobClientCache() {
+  cache2.clear();
+}
+__name(clearAzureBlobClientCache, "clearAzureBlobClientCache");
+function buildClient2(options) {
+  const auth = options.auth;
+  switch (auth.kind) {
+    case "connectionString":
+      return storageBlob.BlobServiceClient.fromConnectionString(auth.connectionString);
+    case "accountKey":
+      return new storageBlob.BlobServiceClient(endpointFor(options, auth.accountName), new storageBlob.StorageSharedKeyCredential(auth.accountName, auth.accountKey));
+    case "sas":
+      return new storageBlob.BlobServiceClient(`${endpointFor(options, auth.accountName)}?${auth.sasToken.replace(/^\?/, "")}`);
+    case "workloadIdentity":
+      return new storageBlob.BlobServiceClient(endpointFor(options, auth.accountName), new identity.DefaultAzureCredential());
+  }
+}
+__name(buildClient2, "buildClient");
+function endpointFor(options, accountName) {
+  var _a3;
+  return (_a3 = options.endpoint) != null ? _a3 : `https://${accountName}.blob.core.windows.net`;
+}
+__name(endpointFor, "endpointFor");
+function authKeyParts2(auth) {
+  switch (auth.kind) {
+    case "connectionString":
+      return {
+        kind: auth.kind,
+        connection: hashSecret(auth.connectionString)
+      };
+    case "accountKey":
+      return {
+        kind: auth.kind,
+        accountName: auth.accountName,
+        key: hashSecret(auth.accountKey)
+      };
+    case "sas":
+      return {
+        kind: auth.kind,
+        accountName: auth.accountName,
+        token: hashSecret(auth.sasToken)
+      };
+    case "workloadIdentity":
+      return {
+        kind: auth.kind,
+        accountName: auth.accountName
+      };
+  }
+}
+__name(authKeyParts2, "authKeyParts");
+
+// src/providers/azure-blob/errors.ts
+var AUTH_CODES = /* @__PURE__ */ new Set([
+  "AuthenticationFailed",
+  "AuthorizationFailure",
+  "AuthorizationPermissionMismatch",
+  "InsufficientAccountPermissions",
+  "InvalidAuthenticationInfo"
+]);
+var NOT_FOUND_CODES = /* @__PURE__ */ new Set([
+  "BlobNotFound",
+  "ContainerNotFound",
+  "ResourceNotFound"
+]);
+function mapAzureError(error) {
+  var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  if (error instanceof StorageError)
+    return error;
+  const azure = error != null ? error : {};
+  const code = (_d = (_c = (_b = (_a3 = azure.details) == null ? void 0 : _a3.errorCode) != null ? _b : azure.code) != null ? _c : azure.name) != null ? _d : "UnknownError";
+  const status = azure.statusCode;
+  const base = {
+    message: `${code}: ${(_e = azure.message) != null ? _e : String(error)}`,
+    provider: AZURE_BLOB_PROVIDER_ID,
+    requestId: (_h = (_g = (_f = azure.response) == null ? void 0 : _f.headers) == null ? void 0 : _g.get) == null ? void 0 : _h.call(_g, "x-ms-request-id"),
+    cause: error
+  };
+  if (status === 429 || code === "ServerBusy") {
+    const retryAfter = (_k = (_j = (_i = azure.response) == null ? void 0 : _i.headers) == null ? void 0 : _j.get) == null ? void 0 : _k.call(_j, "retry-after");
+    return new ThrottledError(__spreadProps(__spreadValues({}, base), {
+      code,
+      retryAfterMs: retryAfter !== void 0 ? Number(retryAfter) * 1e3 : void 0
+    }));
+  }
+  if (NOT_FOUND_CODES.has(code) || status === 404) {
+    return new NotFoundError(__spreadProps(__spreadValues({}, base), {
+      code
+    }));
+  }
+  if (AUTH_CODES.has(code) || status === 403 || status === 401) {
+    return new AuthError(__spreadProps(__spreadValues({}, base), {
+      code
+    }));
+  }
+  if (status !== void 0 && status >= 500) {
+    return new NetworkError(__spreadProps(__spreadValues({}, base), {
+      code
+    }));
+  }
+  return new StorageError(__spreadProps(__spreadValues({}, base), {
+    code,
+    retryable: false
+  }));
+}
+__name(mapAzureError, "mapAzureError");
+
+// src/providers/azure-blob/multipartSessionStore.ts
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var _InMemoryMultipartSessionStore = class _InMemoryMultipartSessionStore {
+  constructor(ttlMs = DEFAULT_TTL_MS) {
+    __publicField(this, "ttlMs");
+    __publicField(this, "sessions");
+    this.ttlMs = ttlMs;
+    this.sessions = /* @__PURE__ */ new Map();
+  }
+  async create(session) {
+    this.evictExpired();
+    this.sessions.set(session.uploadId, session);
+  }
+  async get(uploadId) {
+    const session = this.sessions.get(uploadId);
+    if (!session)
+      return void 0;
+    if (this.isExpired(session)) {
+      this.sessions.delete(uploadId);
+      return void 0;
+    }
+    return session;
+  }
+  async appendBlock(uploadId, block) {
+    const session = await this.get(uploadId);
+    if (session)
+      session.blocks.push(block);
+  }
+  async delete(uploadId) {
+    this.sessions.delete(uploadId);
+  }
+  async list(containerName, blobNamePrefix) {
+    this.evictExpired();
+    return [
+      ...this.sessions.values()
+    ].filter((s) => s.containerName === containerName && (blobNamePrefix === void 0 || s.blobName.startsWith(blobNamePrefix)));
+  }
+  isExpired(session) {
+    return Date.now() - session.createdAt > this.ttlMs;
+  }
+  evictExpired() {
+    for (const [uploadId, session] of this.sessions) {
+      if (this.isExpired(session))
+        this.sessions.delete(uploadId);
+    }
+  }
+};
+__name(_InMemoryMultipartSessionStore, "InMemoryMultipartSessionStore");
+var InMemoryMultipartSessionStore = _InMemoryMultipartSessionStore;
+var DELETE_BATCH_SIZE2 = 256;
+var DEFAULT_PRESIGN_SECONDS2 = 3600;
+var PART_NUMBER_WIDTH = 5;
+var _AzureBlobStorageProvider = class _AzureBlobStorageProvider {
+  constructor(config) {
+    __publicField(this, "bucketName");
+    __publicField(this, "multipart");
+    __publicField(this, "serviceClient");
+    __publicField(this, "container");
+    __publicField(this, "retryPolicy");
+    __publicField(this, "limiter");
+    var _a3, _b, _c;
+    const resolved = resolveObjectStorageOptions(config.options);
+    if (!isAzureBlobStorageOptions(resolved)) {
+      throw new ConfigurationError({
+        message: `AzureBlobStorageProvider requires azure_blob_storage options, got provider "${resolved.provider}"`
+      });
+    }
+    this.bucketName = config.bucketName;
+    this.serviceClient = getAzureBlobServiceClient(resolved);
+    this.container = this.serviceClient.getContainerClient(config.bucketName);
+    this.retryPolicy = (_a3 = config.retry) != null ? _a3 : {};
+    this.limiter = (_b = config.limiter) != null ? _b : createLimiter({
+      max: 10,
+      adaptive: true
+    });
+    this.multipart = new AzureBlobMultipartClient(this.container, this.bucketName, (_c = config.multipartStore) != null ? _c : new InMemoryMultipartSessionStore(), (operation, fn) => this.send(operation, fn));
+  }
+  send(operation, fn) {
+    return instrument(AZURE_BLOB_PROVIDER_ID, operation, () => withRetry(() => fn().catch((error) => Promise.reject(mapAzureError(error))), this.retryPolicy));
+  }
+  block(key) {
+    return this.container.getBlockBlobClient(key);
+  }
+  async getObject(key, options) {
+    const { offset, count } = await this.resolveRange(key, options == null ? void 0 : options.range);
+    const response = await this.send("getObject", () => this.block(key).download(offset, count));
+    if (!response.readableStreamBody) {
+      throw new NotFoundError({
+        message: `Empty body downloading "${key}"`,
+        provider: "azure_blob_storage"
+      });
+    }
+    return {
+      body: response.readableStreamBody,
+      contentLength: response.contentLength,
+      contentType: response.contentType,
+      contentEncoding: response.contentEncoding,
+      contentDisposition: response.contentDisposition,
+      contentLanguage: response.contentLanguage,
+      cacheControl: response.cacheControl,
+      etag: response.etag,
+      lastModified: response.lastModified,
+      metadata: response.metadata
+    };
+  }
+  async resolveRange(key, rangeInput) {
+    var _a3;
+    if (!rangeInput)
+      return {
+        offset: 0
+      };
+    const range = parseRange(rangeInput);
+    if (range.suffixLength !== void 0) {
+      const props = await this.getObjectProperties(key);
+      const total = (_a3 = props.contentLength) != null ? _a3 : 0;
+      const count2 = Math.min(range.suffixLength, total);
+      return {
+        offset: total - count2,
+        count: count2
+      };
+    }
+    const start = range.start;
+    const count = range.end !== void 0 ? range.end - start + 1 : void 0;
+    return {
+      offset: start,
+      count
+    };
+  }
+  async getObjectProperties(key) {
+    const response = await this.send("getObjectProperties", () => this.block(key).getProperties());
+    return {
+      contentLength: response.contentLength,
+      contentType: response.contentType,
+      etag: response.etag,
+      lastModified: response.lastModified,
+      metadata: response.metadata
+    };
+  }
+  async upload(key, body, options) {
+    const blob = this.block(key);
+    const headers = mapHttpHeaders(options);
+    if (body instanceof stream.Readable) {
+      const response2 = await this.send("upload", () => blob.uploadStream(body, options == null ? void 0 : options.partSizeBytes, options == null ? void 0 : options.queueSize, {
+        blobHTTPHeaders: headers,
+        metadata: options == null ? void 0 : options.metadata
+      }));
+      return {
+        key,
+        etag: response2.etag
+      };
+    }
+    const data = typeof body === "string" ? Buffer.from(body) : Buffer.from(body);
+    const response = await this.send("upload", () => blob.upload(data, data.length, {
+      blobHTTPHeaders: headers,
+      metadata: options == null ? void 0 : options.metadata
+    }));
+    return {
+      key,
+      etag: response.etag
+    };
+  }
+  createWriteStream(key, options) {
+    const stream$1 = new stream.PassThrough();
+    let aborted = false;
+    const done = this.send("createWriteStream", () => this.block(key).uploadStream(stream$1, options == null ? void 0 : options.partSizeBytes, options == null ? void 0 : options.queueSize, {
+      blobHTTPHeaders: mapHttpHeaders(options),
+      metadata: options == null ? void 0 : options.metadata
+    })).then((response) => ({
+      key,
+      etag: response.etag
+    }));
+    return {
+      stream: stream$1,
+      done,
+      abort: async () => {
+        if (!aborted) {
+          aborted = true;
+          stream$1.destroy(new Error("upload aborted"));
+        }
+      }
+    };
+  }
+  async delete(key) {
+    await this.send("delete", () => this.block(key).delete());
+  }
+  async deleteMany(keys) {
+    const batchResults = await mapBatched(keys, DELETE_BATCH_SIZE2, this.limiter, async (batch) => Promise.all(batch.map(async (key) => {
+      try {
+        await this.delete(key);
+        return {
+          key,
+          deleted: true
+        };
+      } catch (error) {
+        return {
+          key,
+          deleted: false,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    })));
+    return batchResults.flat();
+  }
+  async list(options) {
+    var _a3, _b;
+    const iterator = this.container.listBlobsFlat({
+      prefix: options == null ? void 0 : options.prefix
+    }).byPage({
+      maxPageSize: options == null ? void 0 : options.limit,
+      continuationToken: (options == null ? void 0 : options.continuationToken) || void 0
+    });
+    const page = await this.send("list", async () => (await iterator.next()).value);
+    const items = ((_b = (_a3 = page == null ? void 0 : page.segment) == null ? void 0 : _a3.blobItems) != null ? _b : []).map((blob) => ({
+      key: blob.name,
+      size: blob.properties.contentLength,
+      etag: blob.properties.etag,
+      lastModified: blob.properties.lastModified
+    }));
+    return {
+      items,
+      nextToken: (page == null ? void 0 : page.continuationToken) || void 0
+    };
+  }
+  iterate(options) {
+    return __asyncGenerator(this, null, function* () {
+      let token;
+      do {
+        const page = yield new __await(this.list({
+          prefix: options == null ? void 0 : options.prefix,
+          limit: options == null ? void 0 : options.pageSize,
+          continuationToken: token
+        }));
+        yield* __yieldStar(page.items);
+        token = page.nextToken;
+      } while (token);
+    });
+  }
+  async listAll(options) {
+    const items = [];
+    try {
+      for (var iter = __forAwait(this.iterate(options)), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+        const item = temp.value;
+        items.push(item);
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+    return items;
+  }
+  async headBucket() {
+    try {
+      const response = await this.send("headBucket", () => this.container.getProperties());
+      return {
+        exists: true,
+        metadata: response.metadata
+      };
+    } catch (error) {
+      if (error instanceof NotFoundError)
+        return {
+          exists: false
+        };
+      throw error;
+    }
+  }
+  async getDownloadUrl(key, options) {
+    return this.generateSasUrl(key, "r", options);
+  }
+  async getUploadUrl(key, options) {
+    const url = await this.generateSasUrl(key, "cw", options);
+    return {
+      key,
+      url
+    };
+  }
+  async generateSasUrl(key, permissions, options) {
+    var _a3;
+    const expiresInSeconds = (_a3 = options == null ? void 0 : options.expiresInSeconds) != null ? _a3 : DEFAULT_PRESIGN_SECONDS2;
+    try {
+      return await this.block(key).generateSasUrl({
+        permissions: storageBlob.BlobSASPermissions.parse(permissions),
+        expiresOn: new Date(Date.now() + expiresInSeconds * 1e3)
+      });
+    } catch (error) {
+      throw new ConfigurationError({
+        message: "SAS generation requires shared key credentials (connectionString or accountKey auth)",
+        provider: "azure_blob_storage",
+        cause: error
+      });
+    }
+  }
+};
+__name(_AzureBlobStorageProvider, "AzureBlobStorageProvider");
+var AzureBlobStorageProvider = _AzureBlobStorageProvider;
+var _a2;
+var AzureBlobMultipartClient = (_a2 = class {
+  constructor(container, containerName, store, send) {
+    __publicField(this, "container");
+    __publicField(this, "containerName");
+    __publicField(this, "store");
+    __publicField(this, "send");
+    this.container = container;
+    this.containerName = containerName;
+    this.store = store;
+    this.send = send;
+  }
+  block(key) {
+    return this.container.getBlockBlobClient(key);
+  }
+  blockIdFor(uploadId, partNumber) {
+    return Buffer.from(`${uploadId}:${String(partNumber).padStart(PART_NUMBER_WIDTH, "0")}`).toString("base64");
+  }
+  async create(key) {
+    const uploadId = crypto.randomUUID();
+    await this.store.create({
+      uploadId,
+      blobName: key,
+      containerName: this.containerName,
+      blocks: [],
+      createdAt: Date.now()
+    });
+    return {
+      uploadId
+    };
+  }
+  async session(uploadId) {
+    const session = await this.store.get(uploadId);
+    if (!session) {
+      throw new MultipartSessionError({
+        message: `Unknown or expired multipart uploadId "${uploadId}"`,
+        provider: "azure_blob_storage"
+      });
+    }
+    return session;
+  }
+  async uploadPart(key, uploadId, partNumber, body, contentLengthBytes) {
+    await this.session(uploadId);
+    const blockId = this.blockIdFor(uploadId, partNumber);
+    const { data, length } = resolveBlockBody(body, contentLengthBytes);
+    await this.send("multipart.uploadPart", () => this.block(key).stageBlock(blockId, data, length));
+    await this.store.appendBlock(uploadId, {
+      blockId,
+      partNumber
+    });
+    return {
+      partNumber,
+      etag: blockId
+    };
+  }
+  async getPartUploadUrl() {
+    throw new ConfigurationError({
+      message: "Azure presigned part upload not supported yet; upload parts server-side via multipart.uploadPart",
+      provider: "azure_blob_storage"
+    });
+  }
+  async complete(key, uploadId, parts) {
+    await this.session(uploadId);
+    const blockIds = [
+      ...parts
+    ].sort((a, b) => a.partNumber - b.partNumber).map((p) => p.etag);
+    const response = await this.send("multipart.complete", () => this.block(key).commitBlockList(blockIds));
+    await this.store.delete(uploadId);
+    return {
+      key,
+      etag: response.etag
+    };
+  }
+  async abort(_key, uploadId) {
+    await this.store.delete(uploadId);
+  }
+  async listParts(_key, uploadId) {
+    const session = await this.session(uploadId);
+    return session.blocks.map((b) => ({
+      partNumber: b.partNumber,
+      etag: b.blockId
+    }));
+  }
+  async listUploads(prefix) {
+    const sessions = await this.store.list(this.containerName, prefix);
+    return sessions.map((s) => ({
+      key: s.blobName,
+      uploadId: s.uploadId,
+      initiatedAt: new Date(s.createdAt)
+    }));
+  }
+}, __name(_a2, "AzureBlobMultipartClient"), _a2);
+function resolveBlockBody(body, contentLengthBytes) {
+  if (body instanceof stream.Readable) {
+    if (contentLengthBytes === void 0) {
+      throw new ValidationError({
+        message: "contentLengthBytes is required when uploading a part from a stream",
+        provider: "azure_blob_storage"
+      });
+    }
+    return {
+      data: body,
+      length: contentLengthBytes
+    };
+  }
+  const data = typeof body === "string" ? Buffer.from(body) : Buffer.from(body);
+  return {
+    data,
+    length: data.length
+  };
+}
+__name(resolveBlockBody, "resolveBlockBody");
+function mapHttpHeaders(options) {
+  return {
+    blobContentType: options == null ? void 0 : options.contentType,
+    blobContentEncoding: options == null ? void 0 : options.contentEncoding,
+    blobCacheControl: options == null ? void 0 : options.cacheControl,
+    blobContentDisposition: options == null ? void 0 : options.contentDisposition,
+    blobContentLanguage: void 0
+  };
+}
+__name(mapHttpHeaders, "mapHttpHeaders");
+var cache3 = new ClientCache();
+function getObjectStorageClient(bucket, options) {
+  const resolved = resolveObjectStorageOptions(options);
+  const optionsHash = crypto.createHash("sha256").update(stableCacheKey(resolved)).digest("hex");
+  const key = `${resolved.provider}:${bucket}:${optionsHash}`;
+  return cache3.getOrCreate(key, () => buildProvider(bucket, resolved));
+}
+__name(getObjectStorageClient, "getObjectStorageClient");
+function buildProvider(bucket, options) {
+  var _a3;
+  if (isAwsS3StorageOptions(options)) {
+    return new AwsS3Provider({
+      bucketName: bucket,
+      options
+    });
+  }
+  if (isAzureBlobStorageOptions(options)) {
+    return new AzureBlobStorageProvider({
+      bucketName: bucket,
+      options
+    });
+  }
+  throw new ConfigurationError({
+    message: `Unsupported object storage provider: "${(_a3 = options == null ? void 0 : options.provider) != null ? _a3 : "unknown"}"`
+  });
+}
+__name(buildProvider, "buildProvider");
+function clearObjectStorageClientCache() {
+  cache3.clear();
+}
+__name(clearObjectStorageClientCache, "clearObjectStorageClientCache");
+
+// src/index-v2.ts
+var OBJECT_STORAGE_PROVIDERS = Object.freeze({
+  AWS_S3: AWS_S3_PROVIDER_ID,
+  AZURE_BLOB_STORAGE: AZURE_BLOB_PROVIDER_ID
+});
+
+exports.AWS_S3_PROVIDER_ID = AWS_S3_PROVIDER_ID;
+exports.AZURE_BLOB_PROVIDER_ID = AZURE_BLOB_PROVIDER_ID;
+exports.AuthError = AuthError;
+exports.AwsS3Provider = AwsS3Provider;
+exports.AzureBlobStorageProvider = AzureBlobStorageProvider;
+exports.ConfigurationError = ConfigurationError;
+exports.InMemoryMultipartSessionStore = InMemoryMultipartSessionStore;
+exports.IntegrityError = IntegrityError;
+exports.MultipartSessionError = MultipartSessionError;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.OBJECT_STORAGE_PROVIDERS = OBJECT_STORAGE_PROVIDERS;
+exports.StorageError = StorageError;
+exports.ThrottledError = ThrottledError;
+exports.ValidationError = ValidationError;
+exports.chunk = chunk;
+exports.clearAwsS3ClientCache = clearAwsS3ClientCache;
+exports.clearAzureBlobClientCache = clearAzureBlobClientCache;
+exports.clearObjectStorageClientCache = clearObjectStorageClientCache;
+exports.createLimiter = createLimiter;
+exports.getAwsS3Client = getAwsS3Client;
+exports.getAzureBlobServiceClient = getAzureBlobServiceClient;
+exports.getDefaultAwsS3OptionsFromEnv = getDefaultAwsS3OptionsFromEnv;
+exports.getDefaultAzureBlobOptionsFromEnv = getDefaultAzureBlobOptionsFromEnv;
+exports.getObjectStorageClient = getObjectStorageClient;
+exports.isAwsS3StorageOptions = isAwsS3StorageOptions;
+exports.isAzureBlobStorageOptions = isAzureBlobStorageOptions;
+exports.isRetryableError = isRetryableError;
+exports.mapAwsError = mapAwsError;
+exports.mapAzureError = mapAzureError;
+exports.mapBatched = mapBatched;
+exports.parseRange = parseRange;
+exports.resolveObjectStorageOptions = resolveObjectStorageOptions;
+exports.resolveOptionsFromEnv = resolveOptionsFromEnv;
+exports.toRangeHeader = toRangeHeader;
+exports.withRetry = withRetry;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index-v2.js.map