@clipto/upload-browser 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0
+
+- 提供基于 XHR adapter 的浏览器上传客户端，将无 HTTP response 的模糊错误统一为 `ERR_NETWORK`，并保留 HTTP、超时与取消语义。
+- 为 PUT 请求增加 15 分钟硬超时，为 multipart part 签名和 single PUT 签名增加独立超时。
+- 支持 multipart 网络错误、超时、429 与 5xx 重试，并保证分片重试最少退避 12 秒；明确 4xx 不重试。
+- single PUT 遇到无 response 的瞬时 `ERR_NETWORK` 时，在限定窗口内重新签名重试。
+- 提供 Safari ArrayBuffer 分片缓存和跨刷新虚拟源恢复，恢复时只读取当前分片而不拼接完整 Blob。
+- 通过可注入的 `UploadPartStorage` 隔离具体持久化实现，并在写入后回读校验分片长度。
+- 保留用户取消的 `UploadCanceledError` 语义，将缺失或损坏的缓存分片归一为不可重试的 `source_unreadable`。

package/README.md

@@ -0,0 +1,60 @@
+# @clipto/upload-browser
+
+Clipto 浏览器上传适配包，为 `@clipto/uploader@0.3.0` 提供 XHR 传输错误归一、Blob 直传，以及可注入存储的 Safari multipart 字节缓存。
+
+## 安装
+
+```bash
+pnpm add @clipto/upload-browser @clipto/uploader@0.3.0 axios@1.20.0
+```
+
+## 使用
+
+```ts
+import {
+  createBrowserUploadHttpClient,
+  createLocalBlobUploader,
+  createSafariUploadCacheManager,
+} from "@clipto/upload-browser";
+
+const cache = createSafariUploadCacheManager({
+  storage: {
+    get: (key) => indexedStorage.get(key),
+    set: (key, value) => indexedStorage.set(key, value),
+    remove: (key) => indexedStorage.remove(key),
+  },
+});
+
+const uploader = createLocalBlobUploader(
+  {
+    signatureApi,
+    httpClient: createBrowserUploadHttpClient(),
+  },
+  { safariCache: cache },
+);
+```
+
+签名接口、任务持久化、业务上报与具体 IndexedDB 实现由宿主注入，本包不包含这些职责。Safari descriptor 保持 `version: 1` wire shape；恢复源应同时向 uploader 注入创建它的 cache manager。
+
+## 公共接口
+
+运行时导出：
+
+- `createBrowserUploadHttpClient`
+- `createLocalBlobUploader`
+- `createSafariUploadCacheManager`
+- `createSafariUploadSource`
+- `isSafariUploadSource`
+- `isSafariUploadCacheDescriptor`
+- `isSafariMultipartCacheEligible`
+
+类型导出：
+
+- `UploadPartStorage`
+- `SafariUploadCacheDescriptor`
+- `SafariUploadSource`
+- `SafariUploadCacheManager`
+
+## 风险
+
+Blob 直传、multipart 重试分类及 Safari 虚拟源读取依赖 `@clipto/uploader@0.3.0` 的私有方法。接点缺失时会尽量降级为普通 SDK 实例，但升级 uploader 前必须重新验证真实 XHR、重试和恢复流程。

package/dist/index.cjs

@@ -0,0 +1,614 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createBrowserUploadHttpClient: () => createBrowserUploadHttpClient,
+  createLocalBlobUploader: () => createLocalBlobUploader,
+  createSafariUploadCacheManager: () => createSafariUploadCacheManager,
+  createSafariUploadSource: () => createSafariUploadSource,
+  isSafariMultipartCacheEligible: () => isSafariMultipartCacheEligible,
+  isSafariUploadCacheDescriptor: () => isSafariUploadCacheDescriptor,
+  isSafariUploadSource: () => isSafariUploadSource
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/browser-upload-http.ts
+var import_axios = __toESM(require("axios"), 1);
+function normalizeTransportError(cause, request) {
+  if (import_axios.default.isCancel(cause)) return cause;
+  if (!import_axios.default.isAxiosError(cause)) return cause;
+  const axiosError = cause;
+  if (axiosError.response) return axiosError;
+  if (request.signal?.aborted || axiosError.code === "ERR_CANCELED") {
+    return new import_axios.default.CanceledError();
+  }
+  if (["ECONNABORTED", "ETIMEDOUT"].includes(axiosError.code || "")) {
+    return axiosError;
+  }
+  const error = new import_axios.default.AxiosError(
+    "Browser upload request failed without an HTTP response",
+    "ERR_NETWORK",
+    request,
+    axiosError.request
+  );
+  error.cause = axiosError;
+  return error;
+}
+function withNormalizedTransportErrors(adapter) {
+  return async (request) => {
+    try {
+      return await adapter(request);
+    } catch (cause) {
+      throw normalizeTransportError(cause, request);
+    }
+  };
+}
+function createBrowserUploadHttpClient(readRestoredParts = false) {
+  if (typeof XMLHttpRequest === "undefined") return void 0;
+  const client = import_axios.default.create({
+    adapter: "xhr",
+    timeout: 0,
+    maxBodyLength: Infinity,
+    maxContentLength: Infinity,
+    proxy: false
+  });
+  const nativeAdapter = withNormalizedTransportErrors(
+    import_axios.default.getAdapter(client.defaults.adapter)
+  );
+  const guardedRestore = readRestoredParts && typeof navigator !== "undefined" && /Safari/.test(navigator.userAgent) && !/Chrome|Chromium|CriOS|Edg|Android/.test(navigator.userAgent);
+  if (guardedRestore) {
+    let readFailure;
+    client.defaults.adapter = async (request) => {
+      if (request.signal?.aborted) throw new import_axios.default.CanceledError();
+      if (readFailure) throw readFailure;
+      if (request.method !== "put" || !(request.data instanceof Blob) || request.data.size === 0) {
+        return nativeAdapter(request);
+      }
+      if (request.data.size > 5 * 1024 * 1024) {
+        throw new import_axios.default.AxiosError(
+          "Restored part exceeds read budget",
+          "UPLOAD_RESTORE_READ_LIMIT"
+        );
+      }
+      const blob = request.data;
+      const failedRead = (cause) => {
+        const error = new import_axios.default.AxiosError(
+          "Cached upload part could not be read. Please select the file again.",
+          "UPLOAD_RESTORE_READ_FAILED"
+        );
+        error.cause = cause;
+        readFailure = error;
+        return error;
+      };
+      const buffer = await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        let done = false;
+        const finish = (error) => {
+          if (done) return;
+          done = true;
+          clearTimeout(timer);
+          request.signal?.removeEventListener?.("abort", onAbort);
+          if (error) {
+            reject(error);
+            if (reader.readyState === 1) reader.abort();
+            return;
+          }
+          const result = reader.result;
+          if (!(result instanceof ArrayBuffer) || result.byteLength !== blob.size) {
+            reject(
+              failedRead(
+                new DOMException("Incomplete part read", "NotReadableError")
+              )
+            );
+            return;
+          }
+          resolve(result);
+        };
+        const onAbort = () => finish(new import_axios.default.CanceledError());
+        const timer = setTimeout(
+          () => finish(
+            new import_axios.default.AxiosError(
+              "Cached part read timed out",
+              "UPLOAD_RESTORE_READ_TIMEOUT"
+            )
+          ),
+          6e4
+        );
+        reader.onload = () => finish();
+        reader.onerror = () => finish(failedRead(reader.error));
+        reader.onabort = onAbort;
+        request.signal?.addEventListener?.("abort", onAbort);
+        if (request.signal?.aborted) return onAbort();
+        try {
+          reader.readAsArrayBuffer(blob);
+        } catch (error) {
+          finish(failedRead(error));
+        }
+      });
+      if (request.signal?.aborted) throw new import_axios.default.CanceledError();
+      if (readFailure) throw readFailure;
+      return nativeAdapter({ ...request, data: buffer });
+    };
+  } else {
+    client.defaults.adapter = nativeAdapter;
+  }
+  client.interceptors.request.use((config) => {
+    config.headers.delete("content-length");
+    return config;
+  });
+  return client;
+}
+
+// src/local-blob-upload.ts
+var import_axios2 = __toESM(require("axios"), 1);
+var import_uploader = require("@clipto/uploader");
+var PUT_REQUEST_TIMEOUT_MS = 15 * 6e4;
+var PART_SIGNATURE_TIMEOUT_MS = 3e4;
+var SINGLE_SIGNATURE_TIMEOUT_MS = 3e4;
+var PART_RETRY_DELAY_MS = 12e3;
+var normalizeRetryMessage = (message) => message.replace(
+  /^(part .* attempt \d+ failed, retry in )\d+ms:/,
+  `$1${PART_RETRY_DELAY_MS}ms:`
+);
+async function withUploadWatchdog(signal, timeoutMs, code, execute) {
+  if (signal.aborted) throw new import_uploader.UploadCanceledError();
+  const controller = new AbortController();
+  let timer;
+  let onAbort = () => {
+  };
+  let reset = () => {
+  };
+  let finished = false;
+  const disarm = () => clearTimeout(timer);
+  const stopped = new Promise((_, reject) => {
+    onAbort = () => {
+      disarm();
+      reject(new import_uploader.UploadCanceledError());
+      controller.abort();
+    };
+    reset = () => {
+      if (finished || controller.signal.aborted) return;
+      disarm();
+      timer = setTimeout(() => {
+        reject(new import_axios2.default.AxiosError("Upload made no progress", code));
+        controller.abort();
+      }, timeoutMs);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    reset();
+  });
+  try {
+    return await Promise.race([
+      execute(controller.signal, reset, disarm),
+      stopped
+    ]);
+  } finally {
+    finished = true;
+    disarm();
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+var isRecoverableUploadError = (error) => {
+  const cause = (0, import_uploader.isUploadError)(error) ? error.cause : error;
+  if (!import_axios2.default.isAxiosError(cause) || cause.code === "ERR_CANCELED") return false;
+  const status = cause.response?.status;
+  if (status) return status === 429 || status >= 500 && status <= 599;
+  return [
+    "ERR_NETWORK",
+    "ECONNABORTED",
+    "ETIMEDOUT",
+    "UPLOAD_PUT_TIMEOUT"
+  ].includes(cause.code || "");
+};
+var isTransientSingleNetworkError = (error) => (0, import_uploader.isUploadError)(error) && error.phase === "putSingle" && import_axios2.default.isAxiosError(error.cause) && error.cause.code === "ERR_NETWORK" && !error.cause.response;
+var isSafariPartRef = (value) => Boolean(
+  value && typeof value === "object" && "kind" in value && value.kind === "safari-array-buffer-part"
+);
+function createLocalBlobUploader(config, options = {}) {
+  const uploader = new import_uploader.CliptoUploader({ ...config, maxPartRetries: 3 });
+  const internals = uploader;
+  if (typeof internals.blobToArrayBuffer !== "function") return uploader;
+  Object.defineProperty(uploader, "blobToArrayBuffer", {
+    value: async (blob) => blob,
+    configurable: false,
+    writable: false
+  });
+  const uploadSingle = typeof internals.uploadSingle === "function" ? internals.uploadSingle.bind(uploader) : void 0;
+  const putData = typeof internals.putData === "function" ? internals.putData.bind(uploader) : void 0;
+  if (!uploadSingle || !putData) return uploader;
+  const beforeRetryPut = /* @__PURE__ */ new WeakMap();
+  const beforePartPut = /* @__PURE__ */ new WeakMap();
+  if (typeof internals.uploadPartOnce === "function" && typeof internals.sleep === "function" && typeof internals.emitWarning === "function" && typeof internals.isRetryable === "function") {
+    const uploadPartOnce = internals.uploadPartOnce.bind(uploader);
+    const sleep = internals.sleep.bind(uploader);
+    const emitWarning = internals.emitWarning.bind(uploader);
+    const logger = config.logger || console;
+    Object.defineProperty(uploader, "logger", {
+      value: {
+        info: logger.info.bind(logger),
+        error: logger.error.bind(logger),
+        warn: (message, ...args) => logger.warn(
+          message === void 0 ? message : normalizeRetryMessage(message),
+          ...args
+        )
+      }
+    });
+    Object.defineProperty(uploader, "emitWarning", {
+      value: (onWarning, warning) => emitWarning(
+        onWarning,
+        warning.code === "PART_RETRY" ? { ...warning, message: normalizeRetryMessage(warning.message) } : warning
+      )
+    });
+    Object.defineProperty(uploader, "isRetryable", {
+      value: isRecoverableUploadError
+    });
+    Object.defineProperty(uploader, "sleep", {
+      value: (ms, signal) => sleep(Math.max(ms, PART_RETRY_DELAY_MS), signal)
+    });
+    Object.defineProperty(uploader, "uploadPartOnce", {
+      value: (...args) => withUploadWatchdog(
+        args[6].signal,
+        PART_SIGNATURE_TIMEOUT_MS,
+        "UPLOAD_PART_SIGNATURE_TIMEOUT",
+        async (signal, _reset, disarm) => {
+          beforePartPut.set(signal, disarm);
+          try {
+            const nextArgs = [...args];
+            if (isSafariPartRef(nextArgs[0])) {
+              try {
+                if (!options.safariCache)
+                  throw new Error("Missing Safari cache");
+                nextArgs[0] = await options.safariCache.getPart(
+                  nextArgs[0].descriptor,
+                  nextArgs[3],
+                  nextArgs[4]
+                );
+              } catch (error) {
+                throw new import_uploader.UploadError({
+                  code: "INVALID_ARGUMENT",
+                  message: "source_unreadable",
+                  phase: "prepare",
+                  cause: error,
+                  objectKey: nextArgs[1],
+                  uploadId: nextArgs[2],
+                  partNumber: nextArgs[3],
+                  resumable: false,
+                  retryable: false
+                });
+              }
+            }
+            nextArgs[6] = { signal };
+            return await uploadPartOnce(...nextArgs);
+          } finally {
+            beforePartPut.delete(signal);
+          }
+        }
+      ).catch((error) => {
+        if (import_axios2.default.isCancel(error) || import_axios2.default.isAxiosError(error) && error.code === "ERR_CANCELED") {
+          throw new import_uploader.UploadCanceledError(args[1]);
+        }
+        if (import_axios2.default.isAxiosError(error) && error.code === "UPLOAD_PART_SIGNATURE_TIMEOUT") {
+          throw new import_uploader.UploadError({
+            code: "SIGNATURE_API_ERROR",
+            message: "Part signature timed out",
+            phase: "signPart",
+            cause: error,
+            objectKey: args[1],
+            uploadId: args[2],
+            partNumber: args[3],
+            resumable: true,
+            retryable: false
+          });
+        }
+        throw error;
+      })
+    });
+  }
+  Object.defineProperty(uploader, "putData", {
+    value: (...args) => {
+      if (args[5].aborted) throw new import_uploader.UploadCanceledError();
+      beforeRetryPut.get(args[5])?.();
+      beforePartPut.get(args[5])?.();
+      return withUploadWatchdog(
+        args[5],
+        PUT_REQUEST_TIMEOUT_MS,
+        "UPLOAD_PUT_TIMEOUT",
+        (signal) => {
+          const nextArgs = [...args];
+          nextArgs[5] = signal;
+          nextArgs[6] = (loaded) => {
+            if (signal.aborted) return;
+            args[6]?.(loaded);
+          };
+          return putData(...nextArgs);
+        }
+      );
+    }
+  });
+  Object.defineProperty(uploader, "uploadSingle", {
+    value: async (...args) => {
+      const signal = args[6].signal;
+      let deadline = 0;
+      let lastError;
+      for (let attempt = 0; attempt <= 2; attempt += 1) {
+        if (signal.aborted) throw new import_uploader.UploadCanceledError(args[1]);
+        if (attempt === 0) {
+          try {
+            return await withUploadWatchdog(
+              signal,
+              SINGLE_SIGNATURE_TIMEOUT_MS,
+              "UPLOAD_SINGLE_SIGNATURE_TIMEOUT",
+              async (attemptSignal, _reset, disarm) => {
+                beforeRetryPut.set(attemptSignal, disarm);
+                try {
+                  const nextArgs = [...args];
+                  nextArgs[6] = { signal: attemptSignal };
+                  return await uploadSingle(...nextArgs);
+                } finally {
+                  beforeRetryPut.delete(attemptSignal);
+                }
+              }
+            );
+          } catch (error) {
+            if (import_axios2.default.isAxiosError(error) && error.code === "UPLOAD_SINGLE_SIGNATURE_TIMEOUT") {
+              throw new import_uploader.UploadError({
+                code: "SIGNATURE_API_ERROR",
+                message: "Single upload signature timed out",
+                phase: "signSingle",
+                cause: error,
+                objectKey: args[1],
+                retryable: false
+              });
+            }
+            if (!isTransientSingleNetworkError(error)) throw error;
+            lastError = error;
+            deadline = Date.now() + 15e3;
+          }
+          continue;
+        }
+        if (Date.now() >= deadline) throw lastError;
+        const controller = new AbortController();
+        let timer;
+        let delayTimer;
+        let onAbort = () => {
+        };
+        try {
+          const stopped = new Promise((_, reject) => {
+            onAbort = () => {
+              controller.abort();
+              reject(new import_uploader.UploadCanceledError(args[1]));
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            timer = setTimeout(
+              () => {
+                controller.abort();
+                reject(lastError);
+              },
+              Math.max(0, deadline - Date.now())
+            );
+          });
+          await Promise.race([
+            new Promise((resolve) => {
+              delayTimer = setTimeout(resolve, 500 * attempt);
+            }),
+            stopped
+          ]);
+          if (signal.aborted) throw new import_uploader.UploadCanceledError(args[1]);
+          if (Date.now() >= deadline) throw lastError;
+          args[5].reset();
+          args[5].report(0);
+          const retryArgs = [...args];
+          retryArgs[6] = { signal: controller.signal };
+          beforeRetryPut.set(controller.signal, () => {
+            if (signal.aborted) throw new import_uploader.UploadCanceledError(args[1]);
+            if (controller.signal.aborted || Date.now() >= deadline)
+              throw lastError;
+            clearTimeout(timer);
+          });
+          return await Promise.race([uploadSingle(...retryArgs), stopped]);
+        } catch (error) {
+          if (signal.aborted) throw new import_uploader.UploadCanceledError(args[1]);
+          if (!isTransientSingleNetworkError(error)) throw error;
+          lastError = error;
+        } finally {
+          beforeRetryPut.delete(controller.signal);
+          clearTimeout(timer);
+          clearTimeout(delayTimer);
+          signal.removeEventListener("abort", onAbort);
+        }
+      }
+      throw lastError;
+    }
+  });
+  return uploader;
+}
+
+// src/safari-upload-part-cache.ts
+var DEFAULT_PART_SIZE = 5 * 1024 * 1024;
+var CACHE_VERSION = 1;
+var CACHE_PREFIX = "safari_upload_part_cache";
+var SafariUploadSourceUnreadableError = class extends Error {
+  constructor() {
+    super("source_unreadable");
+    this.code = "SOURCE_UNREADABLE";
+    this.retryable = false;
+    this.name = "SafariUploadSourceUnreadableError";
+  }
+};
+var manifestKey = (cacheId) => `${CACHE_PREFIX}:${cacheId}:manifest`;
+var partKey = (cacheId, partNumber) => `${CACHE_PREFIX}:${cacheId}:part:${partNumber}`;
+function isSafariMultipartCacheEligible(size, userAgent = typeof navigator === "undefined" ? "" : navigator.userAgent) {
+  return size > DEFAULT_PART_SIZE && /Safari/.test(userAgent) && !/Chrome|Chromium|CriOS|Edg|Android/.test(userAgent);
+}
+function isSafariUploadCacheDescriptor(value) {
+  if (!value || typeof value !== "object") return false;
+  const descriptor = value;
+  return descriptor.kind === "safari-array-buffer-parts" && descriptor.version === CACHE_VERSION && typeof descriptor.cacheId === "string" && descriptor.cacheId.length > 0 && Number.isSafeInteger(descriptor.totalSize) && (descriptor.totalSize || 0) > 0 && Number.isSafeInteger(descriptor.partSize) && (descriptor.partSize || 0) > 0 && descriptor.partCount === Math.ceil((descriptor.totalSize || 0) / (descriptor.partSize || 1)) && Boolean(descriptor.file) && typeof descriptor.file?.name === "string" && typeof descriptor.file?.type === "string" && typeof descriptor.file?.lastModified === "number";
+}
+function createSafariUploadSource(descriptor) {
+  return {
+    kind: "safari-array-buffer-source",
+    descriptor,
+    size: descriptor.totalSize,
+    type: descriptor.file.type,
+    name: descriptor.file.name,
+    lastModified: descriptor.file.lastModified,
+    slice(start = 0, end = descriptor.totalSize) {
+      const partNumber = Math.floor(start / descriptor.partSize) + 1;
+      return createPartRef(descriptor, partNumber, end - start);
+    }
+  };
+}
+function isSafariUploadSource(value) {
+  return Boolean(
+    value && typeof value === "object" && value.kind === "safari-array-buffer-source"
+  );
+}
+function createSafariUploadCacheManager({
+  storage,
+  logger = console
+}) {
+  const cleanup = async (descriptor) => {
+    await Promise.allSettled([
+      ...Array.from(
+        { length: descriptor.partCount },
+        (_, index) => storage.remove(partKey(descriptor.cacheId, index + 1))
+      ),
+      storage.remove(manifestKey(descriptor.cacheId))
+    ]);
+  };
+  const create = async (file, cacheId, options) => {
+    const partSize = options?.partSize ?? DEFAULT_PART_SIZE;
+    const descriptor = {
+      kind: "safari-array-buffer-parts",
+      version: CACHE_VERSION,
+      cacheId,
+      totalSize: file.size,
+      partSize,
+      partCount: Math.ceil(file.size / partSize),
+      file: options?.metadata ?? {
+        name: "name" in file && typeof file.name === "string" ? file.name : "upload",
+        type: file.type,
+        lastModified: "lastModified" in file && typeof file.lastModified === "number" ? file.lastModified : Date.now()
+      }
+    };
+    try {
+      for (let partNumber = 1; partNumber <= descriptor.partCount; partNumber++) {
+        const expected = expectedPartSize(descriptor, partNumber);
+        const start = (partNumber - 1) * partSize;
+        const bytes = await readBlobPart(file.slice(start, start + expected));
+        if (bytes.byteLength !== expected)
+          throw new Error("Invalid source part");
+        const key = partKey(cacheId, partNumber);
+        await storage.set(key, bytes);
+        const stored = await storage.get(key);
+        if (!(stored instanceof ArrayBuffer) || stored.byteLength !== expected) {
+          throw new Error("Invalid persisted part");
+        }
+      }
+      await storage.set(manifestKey(cacheId), descriptor);
+      const manifest = await storage.get(manifestKey(cacheId));
+      if (!isSafariUploadCacheDescriptor(manifest)) {
+        throw new Error("Invalid persisted manifest");
+      }
+      return descriptor;
+    } catch (error) {
+      await cleanup(descriptor);
+      logger.warn(
+        "Safari upload byte cache unavailable, falling back to Blob",
+        error
+      );
+      return null;
+    }
+  };
+  const validate = async (descriptor) => {
+    const stored = await storage.get(
+      manifestKey(descriptor.cacheId)
+    );
+    return isSafariUploadCacheDescriptor(stored) && stored.totalSize === descriptor.totalSize && stored.partSize === descriptor.partSize && stored.partCount === descriptor.partCount;
+  };
+  const getPart = async (descriptor, partNumber, expectedLength) => {
+    if (partNumber < 1 || partNumber > descriptor.partCount || expectedLength !== expectedPartSize(descriptor, partNumber)) {
+      throw new SafariUploadSourceUnreadableError();
+    }
+    try {
+      const bytes = await storage.get(
+        partKey(descriptor.cacheId, partNumber)
+      );
+      if (!(bytes instanceof ArrayBuffer) || bytes.byteLength !== expectedLength) {
+        throw new SafariUploadSourceUnreadableError();
+      }
+      return bytes;
+    } catch (error) {
+      if (error instanceof SafariUploadSourceUnreadableError) throw error;
+      throw new SafariUploadSourceUnreadableError();
+    }
+  };
+  return { create, validate, cleanup, getPart };
+}
+function readBlobPart(blob) {
+  if (typeof blob.arrayBuffer === "function") return blob.arrayBuffer();
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject(reader.error);
+    reader.readAsArrayBuffer(blob);
+  });
+}
+function expectedPartSize(descriptor, partNumber) {
+  return Math.min(
+    descriptor.partSize,
+    descriptor.totalSize - (partNumber - 1) * descriptor.partSize
+  );
+}
+function createPartRef(descriptor, partNumber, size) {
+  return {
+    kind: "safari-array-buffer-part",
+    descriptor,
+    partNumber,
+    size,
+    type: descriptor.file.type,
+    slice(start = 0, end = size) {
+      return createPartRef(descriptor, partNumber, end - start);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBrowserUploadHttpClient,
+  createLocalBlobUploader,
+  createSafariUploadCacheManager,
+  createSafariUploadSource,
+  isSafariMultipartCacheEligible,
+  isSafariUploadCacheDescriptor,
+  isSafariUploadSource
+});
+//# sourceMappingURL=index.cjs.map