web-sdk-pp-detection 0.3.0 → 0.3.2

package/dist/index.d.ts

@@ -138,9 +138,17 @@ interface PPDetectionProgressEvent {
     readonly status: "start" | "progress" | "complete";
     readonly loadedBytes?: number;
     readonly totalBytes?: number;
+    readonly attempt?: number;
+    readonly maxAttempts?: number;
     readonly fallback?: PPDetectionFallback;
 }
+interface ModelDownloadOptions {
+    readonly timeoutMs?: number;
+    readonly idleTimeoutMs?: number;
+    readonly maxRetries?: number;
+}
 interface CreatePPDetectionOptions {
+    readonly download?: ModelDownloadOptions;
     readonly allowExperimental?: boolean;
     readonly allowFallback?: boolean;
     readonly backend?: BackendPreference;
@@ -518,10 +526,13 @@ type ModelFetcher = (input: RequestInfo | URL, init?: RequestInit) => Promise<Re
 interface ModelDownloadProgress {
     readonly loadedBytes: number;
     readonly totalBytes?: number;
+    readonly attempt?: number;
+    readonly maxAttempts?: number;
 }
 interface LoadModelAssetOptions {
     readonly fetcher?: ModelFetcher;
     readonly signal?: AbortSignal;
+    readonly download?: ModelDownloadOptions;
     readonly onProgress?: (progress: ModelDownloadProgress) => void;
 }
 interface ModelBytes {
@@ -549,6 +560,7 @@ interface ModelCache {
 }
 
 interface ModelManagerOptions {
+    readonly download?: ModelDownloadOptions;
     readonly fetcher?: ModelFetcher;
     readonly cache?: "memory" | "indexeddb" | false | ModelCache;
 }
@@ -576,6 +588,7 @@ interface LoadedManagedModel {
 }
 declare class ModelManager {
     private readonly fetcher?;
+    private readonly download;
     private readonly cache;
     private readonly coordinator;
     private readonly lifecycle;
@@ -635,11 +648,11 @@ declare class IndexedDBModelCache implements ModelCache {
 declare global {
     var __PPDETECTION_SCRIPT_URL__: string | undefined;
 }
-declare const CURRENT_SDK_VERSION = "0.3.0";
+declare const CURRENT_SDK_VERSION = "0.3.2";
 
 declare function probePPDetectionCapabilities(options?: CapabilityProbeOptions): DetectionCapabilities;
 
 declare function createPPDetection(options?: CreatePPDetectionOptions): Promise<PPDetectionDetectorImplementation>;
 declare function clearModelCache(): Promise<void>;
 
-export { type Backend, type BackendPreference, CURRENT_SDK_VERSION, type CacheEstimate, type CapabilityProbeOptions, type CreateOrtSessionOptions, type CreatePPDetectionOptions, type DecodedImage, type DetectOptions, type Detection, type DetectionBox, type DetectionCapabilities, type DetectionManifest, type DetectionModelVariant, type DetectionPoint, type DetectionPostprocessing, type DetectionPreprocessing, type DetectionTimings, type ExecutionCandidate, type ExecutionMode, type ExecutionPlan, type ImageRaster, type ImageSource, IndexedDBModelCache, type IndexedDBModelCacheOptions, type LoadManagedModelOptions, type LoadModelAssetOptions, type LoadedManagedModel, MemoryModelCache, type ModelBackend, type ModelBytes, type ModelCache, type ModelDownloadProgress, type ModelFetcher, type ModelInfo, ModelManager, type ModelManagerOptions, type ModelManifest, type ModelManifestMetadata, type ModelManifestSource, type ModelManifestVariant, type ModelPrecision, type ModelSource, type ModelSourceFailure, type ModelSourceKind, type ModelSourceSelection, type ModelVariant, type OrtModule, type OrtSessionHandle, type PPDetectionDetector, PPDetectionError, type PPDetectionErrorCode, type PPDetectionFallback, type PPDetectionLoadTimings, type PPDetectionModel, type PPDetectionModelInfo, type PPDetectionModelSourceInfo, type PPDetectionProgressEvent, type PPDetectionResult, type PPDetectionRuntimeInfo, type Precision, type ResolveModelAssetSelection, type ResolvedModelAsset, type RuntimeDetectionManifest, type RuntimeInfo, type SelectExecutionOptions, type TensorContract, type TimingBreakdown, type WorkerOrtOptions, type WorkerRequest, type WorkerResponse, adaptModelManifest, clearModelCache, createOrtSession, createPPDetection, loadModelAsset, parseDetectionManifest, parseModelManifest, probeCapabilities, probePPDetectionCapabilities, resolveModelAsset, selectExecutionPlan };
+export { type Backend, type BackendPreference, CURRENT_SDK_VERSION, type CacheEstimate, type CapabilityProbeOptions, type CreateOrtSessionOptions, type CreatePPDetectionOptions, type DecodedImage, type DetectOptions, type Detection, type DetectionBox, type DetectionCapabilities, type DetectionManifest, type DetectionModelVariant, type DetectionPoint, type DetectionPostprocessing, type DetectionPreprocessing, type DetectionTimings, type ExecutionCandidate, type ExecutionMode, type ExecutionPlan, type ImageRaster, type ImageSource, IndexedDBModelCache, type IndexedDBModelCacheOptions, type LoadManagedModelOptions, type LoadModelAssetOptions, type LoadedManagedModel, MemoryModelCache, type ModelBackend, type ModelBytes, type ModelCache, type ModelDownloadOptions, type ModelDownloadProgress, type ModelFetcher, type ModelInfo, ModelManager, type ModelManagerOptions, type ModelManifest, type ModelManifestMetadata, type ModelManifestSource, type ModelManifestVariant, type ModelPrecision, type ModelSource, type ModelSourceFailure, type ModelSourceKind, type ModelSourceSelection, type ModelVariant, type OrtModule, type OrtSessionHandle, type PPDetectionDetector, PPDetectionError, type PPDetectionErrorCode, type PPDetectionFallback, type PPDetectionLoadTimings, type PPDetectionModel, type PPDetectionModelInfo, type PPDetectionModelSourceInfo, type PPDetectionProgressEvent, type PPDetectionResult, type PPDetectionRuntimeInfo, type Precision, type ResolveModelAssetSelection, type ResolvedModelAsset, type RuntimeDetectionManifest, type RuntimeInfo, type SelectExecutionOptions, type TensorContract, type TimingBreakdown, type WorkerOrtOptions, type WorkerRequest, type WorkerResponse, adaptModelManifest, clearModelCache, createOrtSession, createPPDetection, loadModelAsset, parseDetectionManifest, parseModelManifest, probeCapabilities, probePPDetectionCapabilities, resolveModelAsset, selectExecutionPlan };

package/dist/index.js

@@ -371,34 +371,58 @@ function clipBicubic(value) {
   const rounded = value >> BICUBIC_PRECISION_BITS;
   return Math.max(0, Math.min(255, rounded));
 }
-function bicubicChannel(raster, resizedWidth, resizedHeight, channel) {
+function writeBicubicChannels(raster, resizedWidth, resizedHeight, target) {
   const horizontal = createBicubicAxis(raster.width, resizedWidth);
   const vertical = createBicubicAxis(raster.height, resizedHeight);
-  const intermediate = new Uint8Array(raster.height * resizedWidth);
+  const rowStride = resizedWidth * 3;
+  const intermediate = new Uint8Array(raster.height * rowStride);
   for (let y = 0; y < raster.height; y += 1) {
+    const sourceRow = y * raster.width * 4;
+    const targetRow = y * rowStride;
     for (let x = 0; x < resizedWidth; x += 1) {
       const [start, count] = horizontal.bounds[x];
       const coefficients = horizontal.coefficients[x];
-      let sum = BICUBIC_ROUNDING;
+      let red = BICUBIC_ROUNDING;
+      let green = BICUBIC_ROUNDING;
+      let blue = BICUBIC_ROUNDING;
+      let source2 = sourceRow + start * 4;
       for (let index = 0; index < count; index += 1) {
-        sum += raster.rgba[(y * raster.width + start + index) * 4 + channel] * coefficients[index];
+        const coefficient = coefficients[index];
+        red += raster.rgba[source2] * coefficient;
+        green += raster.rgba[source2 + 1] * coefficient;
+        blue += raster.rgba[source2 + 2] * coefficient;
+        source2 += 4;
       }
-      intermediate[y * resizedWidth + x] = clipBicubic(sum);
+      const offset = targetRow + x * 3;
+      intermediate[offset] = clipBicubic(red);
+      intermediate[offset + 1] = clipBicubic(green);
+      intermediate[offset + 2] = clipBicubic(blue);
     }
   }
-  const output = new Uint8Array(resizedWidth * resizedHeight);
+  const plane = target.inputWidth * target.inputHeight;
   for (let y = 0; y < resizedHeight; y += 1) {
     const [start, count] = vertical.bounds[y];
     const coefficients = vertical.coefficients[y];
+    const sourceRow = start * rowStride;
+    const targetRow = (y + target.padTop) * target.inputWidth + target.padLeft;
     for (let x = 0; x < resizedWidth; x += 1) {
-      let sum = BICUBIC_ROUNDING;
+      let red = BICUBIC_ROUNDING;
+      let green = BICUBIC_ROUNDING;
+      let blue = BICUBIC_ROUNDING;
+      let source2 = sourceRow + x * 3;
       for (let index = 0; index < count; index += 1) {
-        sum += intermediate[(start + index) * resizedWidth + x] * coefficients[index];
+        const coefficient = coefficients[index];
+        red += intermediate[source2] * coefficient;
+        green += intermediate[source2 + 1] * coefficient;
+        blue += intermediate[source2 + 2] * coefficient;
+        source2 += rowStride;
       }
-      output[y * resizedWidth + x] = clipBicubic(sum);
+      const offset = targetRow + x;
+      target.data[offset] = target.values[clipBicubic(red)];
+      target.data[plane + offset] = target.values[256 + clipBicubic(green)];
+      target.data[plane * 2 + offset] = target.values[512 + clipBicubic(blue)];
     }
   }
-  return output;
 }
 function preprocessImage(raster, preprocessing) {
   const inputWidth = preprocessing.size.width;
@@ -425,18 +449,35 @@ function preprocessImage(raster, preprocessing) {
   const mean = normalize ? preprocessing.mean ?? [0, 0, 0] : [0, 0, 0];
   const std = normalize ? preprocessing.std ?? [1, 1, 1] : [1, 1, 1];
   const interpolation2 = preprocessing.interpolation ?? "bilinear";
+  const bicubicValues = doResize && interpolation2 === "bicubic" ? new Float32Array(256 * 3) : void 0;
   for (let channel = 0; channel < 3; channel += 1) {
     const padding = normalize && mean[channel] !== 0 ? -mean[channel] / std[channel] : 0;
     data.fill(padding, channel * plane, (channel + 1) * plane);
-    const bicubic = doResize && interpolation2 === "bicubic" ? bicubicChannel(raster, resizedWidth, resizedHeight, channel) : void 0;
+    if (bicubicValues) {
+      for (let pixel = 0; pixel < 256; pixel += 1) {
+        const scaled = rescale ? pixel * preprocessing.rescaleFactor : pixel;
+        bicubicValues[channel * 256 + pixel] = normalize ? (scaled - mean[channel]) / std[channel] : scaled;
+      }
+      continue;
+    }
     for (let y = 0; y < resizedHeight; y += 1) {
       for (let x = 0; x < resizedWidth; x += 1) {
-        const pixel = bicubic ? bicubic[y * resizedWidth + x] : doResize ? bilinearChannel(raster, x, y, resizedWidth, resizedHeight, channel) : sampleChannel(raster, x, y, channel);
+        const pixel = doResize ? bilinearChannel(raster, x, y, resizedWidth, resizedHeight, channel) : sampleChannel(raster, x, y, channel);
         const scaled = rescale ? pixel * preprocessing.rescaleFactor : pixel;
         data[channel * plane + (y + padTop) * inputWidth + x + padLeft] = normalize ? (scaled - mean[channel]) / std[channel] : scaled;
       }
     }
   }
+  if (bicubicValues) {
+    writeBicubicChannels(raster, resizedWidth, resizedHeight, {
+      data,
+      inputWidth,
+      inputHeight,
+      padLeft,
+      padTop,
+      values: bicubicValues
+    });
+  }
   return {
     data,
     dims: [1, 3, inputHeight, inputWidth],
@@ -1433,11 +1474,36 @@ async function verifyModelIntegrity(bytes, expected, signal) {
 }
 
 // src/model/download.ts
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var RetryableDownloadError = class extends PPDetectionError {
+  constructor(message, details = {}, cause) {
+    super("MODEL_DOWNLOAD_FAILED", message, details, { cause });
+  }
+};
+function resolveDownloadOptions(options = {}) {
+  if (options === null || typeof options !== "object")
+    throw new PPDetectionError("INVALID_INPUT", "\u4E0B\u8F7D\u914D\u7F6E\u5FC5\u987B\u662F\u5BF9\u8C61");
+  const resolved = {
+    timeoutMs: options.timeoutMs === void 0 ? 18e4 : options.timeoutMs,
+    idleTimeoutMs: options.idleTimeoutMs === void 0 ? 3e4 : options.idleTimeoutMs,
+    maxRetries: options.maxRetries === void 0 ? 2 : options.maxRetries
+  };
+  for (const [key, value] of Object.entries(resolved)) {
+    const maximum = key === "maxRetries" ? 5 : 2147483647;
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximum)
+      throw new PPDetectionError("INVALID_INPUT", "\u4E0B\u8F7D\u53C2\u6570\u5FC5\u987B\u4E3A\u5141\u8BB8\u8303\u56F4\u5185\u7684\u5B89\u5168\u6574\u6570", {
+        parameter: key,
+        value,
+        maximum
+      });
+  }
+  return resolved;
+}
 function now() {
   return globalThis.performance?.now() ?? Date.now();
 }
 function aborted(error, signal) {
-  return signal?.aborted === true || error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+  return signal?.aborted === true || error instanceof Error && error.name === "AbortError";
 }
 function throwIfAborted3(signal) {
   if (signal?.aborted) throw new PPDetectionError("ABORTED", "\u6A21\u578B\u4E0B\u8F7D\u5DF2\u53D6\u6D88");
@@ -1465,106 +1531,206 @@ function validatePartialResponse(response, expectedBytes) {
     });
   }
 }
-async function readResponse(response, expectedBytes, signal, onProgress) {
-  const totalBytes = contentLength(response, expectedBytes);
-  if (!response.body) {
-    const bytes2 = await response.arrayBuffer();
-    throwIfAborted3(signal);
-    onProgress?.({ loadedBytes: bytes2.byteLength, totalBytes });
-    return bytes2;
+function cancelQuietly(cancel) {
+  try {
+    void Promise.resolve(cancel()).catch(() => void 0);
+  } catch {
   }
-  const reader = response.body.getReader();
-  const chunks = [];
-  let loadedBytes = 0;
+}
+async function downloadAttempt(asset, fetcher, options, policy, attempt) {
+  const controller = new AbortController();
+  let response;
+  let reader;
+  let active = true;
+  let cancelledBody = false;
+  let stopError;
+  let totalTimer;
+  let idleTimer;
+  let rejectStop;
+  const stopped = new Promise((_resolve, reject) => {
+    rejectStop = reject;
+  });
+  void stopped.catch(() => void 0);
+  const cancelBody = (reason) => {
+    if (cancelledBody || !reader && !response?.body) return;
+    cancelledBody = true;
+    if (reader) cancelQuietly(() => reader.cancel(reason));
+    else cancelQuietly(() => response.body.cancel(reason));
+  };
+  const stop = (error) => {
+    if (!active || stopError) return;
+    stopError = error;
+    rejectStop(error);
+    controller.abort();
+    cancelBody(error);
+  };
+  const abort = () => stop(new PPDetectionError("ABORTED", "\u6A21\u578B\u4E0B\u8F7D\u5DF2\u53D6\u6D88"));
+  const renewIdle = () => {
+    clearTimeout(idleTimer);
+    if (policy.idleTimeoutMs > 0)
+      idleTimer = setTimeout(
+        () => stop(
+          new RetryableDownloadError("\u6A21\u578B\u4E0B\u8F7D\u957F\u65F6\u95F4\u6CA1\u6709\u65B0\u589E\u5B57\u8282", {
+            idleTimeoutMs: policy.idleTimeoutMs
+          })
+        ),
+        policy.idleTimeoutMs
+      );
+  };
+  const checkActive = () => {
+    if (stopError) throw stopError;
+    throwIfAborted3(options.signal);
+  };
+  const network = async (operation) => {
+    try {
+      checkActive();
+      const value = await Promise.race([operation(), stopped]);
+      checkActive();
+      return value;
+    } catch (error) {
+      if (stopError) throw stopError;
+      if (aborted(error, options.signal))
+        throw new PPDetectionError("ABORTED", "\u6A21\u578B\u4E0B\u8F7D\u5DF2\u53D6\u6D88", {}, { cause: error });
+      if (error instanceof PPDetectionError) throw error;
+      throw new RetryableDownloadError(
+        "\u6A21\u578B\u4E0B\u8F7D\u8BF7\u6C42\u6216\u54CD\u5E94\u8BFB\u53D6\u5931\u8D25",
+        { sourceKind: asset.source.kind, downloadUrl: asset.source.downloadUrl },
+        error
+      );
+    }
+  };
+  const report = (loadedBytes) => {
+    checkActive();
+    options.onProgress?.({
+      loadedBytes,
+      totalBytes: asset.source.bytes,
+      attempt,
+      maxAttempts: policy.maxRetries + 1
+    });
+    checkActive();
+  };
+  options.signal?.addEventListener("abort", abort, { once: true });
   try {
+    throwIfAborted3(options.signal);
+    if (policy.timeoutMs > 0)
+      totalTimer = setTimeout(
+        () => stop(
+          new RetryableDownloadError("\u6A21\u578B\u4E0B\u8F7D\u8D85\u8FC7\u8BF7\u6C42\u603B\u65F6\u9650", { timeoutMs: policy.timeoutMs })
+        ),
+        policy.timeoutMs
+      );
+    renewIdle();
+    report(0);
+    response = await network(
+      () => Promise.resolve(
+        fetcher(asset.source.downloadUrl, {
+          signal: controller.signal,
+          ...attempt > 1 ? { cache: "reload" } : {}
+        })
+      ).then((value) => {
+        response = value;
+        if (!active || stopError) cancelBody(stopError);
+        return value;
+      })
+    );
+    if (!response.ok) {
+      const details = {
+        sourceKind: asset.source.kind,
+        status: response.status,
+        statusText: response.statusText
+      };
+      if (RETRYABLE_STATUSES.has(response.status))
+        throw new RetryableDownloadError("\u6A21\u578B\u4E0B\u8F7D\u8FD4\u56DE\u53EF\u91CD\u8BD5\u72B6\u6001", details);
+      throw new PPDetectionError("MODEL_DOWNLOAD_FAILED", "\u6A21\u578B\u4E0B\u8F7D\u8FD4\u56DE\u975E\u6210\u529F\u72B6\u6001", details);
+    }
+    validatePartialResponse(response, asset.source.bytes);
+    contentLength(response, asset.source.bytes);
+    if (!response.body) {
+      const bytes2 = await network(() => response.arrayBuffer());
+      report(bytes2.byteLength);
+      return bytes2;
+    }
+    reader = response.body.getReader();
+    const chunks = [];
+    let loadedBytes = 0;
     while (true) {
-      throwIfAborted3(signal);
-      const chunk = await reader.read();
+      const chunk = await network(() => reader.read());
       if (chunk.done) break;
+      if (chunk.value.byteLength === 0) continue;
       loadedBytes += chunk.value.byteLength;
-      if (loadedBytes > expectedBytes) {
+      if (loadedBytes > asset.source.bytes)
         throw new PPDetectionError("MODEL_INTEGRITY_FAILED", "\u6A21\u578B\u54CD\u5E94\u8D85\u8FC7\u6E05\u5355\u58F0\u660E\u5927\u5C0F", {
-          expectedBytes,
+          expectedBytes: asset.source.bytes,
           loadedBytes
         });
-      }
       chunks.push(chunk.value);
-      onProgress?.({ loadedBytes, totalBytes });
+      renewIdle();
+      report(loadedBytes);
     }
+    const bytes = new Uint8Array(loadedBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    report(loadedBytes);
+    return bytes.buffer;
   } catch (error) {
+    controller.abort();
+    cancelBody(error);
+    throw error;
+  } finally {
+    active = false;
+    clearTimeout(totalTimer);
+    clearTimeout(idleTimer);
+    options.signal?.removeEventListener("abort", abort);
     try {
-      await reader.cancel(error);
+      reader?.releaseLock();
     } catch {
     }
-    throw error;
-  } finally {
-    reader.releaseLock();
   }
-  const bytes = new Uint8Array(loadedBytes);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  onProgress?.({ loadedBytes, totalBytes });
-  return bytes.buffer;
+}
+function waitForRetry(delayMs, signal) {
+  throwIfAborted3(signal);
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      reject(new PPDetectionError("ABORTED", "\u6A21\u578B\u4E0B\u8F7D\u5DF2\u53D6\u6D88"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, delayMs);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+  });
 }
 async function loadModelAsset(asset, options = {}) {
   throwIfAborted3(options.signal);
+  const policy = resolveDownloadOptions(options.download);
   const fetcher = options.fetcher ?? globalThis.fetch?.bind(globalThis);
   if (!fetcher)
     throw new PPDetectionError("MODEL_DOWNLOAD_FAILED", "\u5F53\u524D\u73AF\u5883\u6CA1\u6709 fetch API", {
       sourceKind: asset.source.kind
     });
   const downloadStarted = now();
-  let response;
-  try {
-    response = await fetcher(asset.source.downloadUrl, { signal: options.signal });
-  } catch (error) {
-    if (aborted(error, options.signal))
-      throw new PPDetectionError("ABORTED", "\u6A21\u578B\u4E0B\u8F7D\u5DF2\u53D6\u6D88", {}, { cause: error });
-    throw new PPDetectionError(
-      "MODEL_DOWNLOAD_FAILED",
-      "\u6A21\u578B\u4E0B\u8F7D\u8BF7\u6C42\u5931\u8D25",
-      {
-        sourceKind: asset.source.kind,
-        downloadUrl: asset.source.downloadUrl
-      },
-      { cause: error }
-    );
-  }
-  if (!response.ok) {
-    throw new PPDetectionError("MODEL_DOWNLOAD_FAILED", "\u6A21\u578B\u4E0B\u8F7D\u8FD4\u56DE\u975E\u6210\u529F\u72B6\u6001", {
-      sourceKind: asset.source.kind,
-      status: response.status,
-      statusText: response.statusText
-    });
-  }
-  validatePartialResponse(response, asset.source.bytes);
   let bytes;
-  try {
-    bytes = await readResponse(response, asset.source.bytes, options.signal, options.onProgress);
-  } catch (error) {
-    if (error instanceof PPDetectionError) throw error;
-    if (aborted(error, options.signal))
-      throw new PPDetectionError("ABORTED", "\u6A21\u578B\u4E0B\u8F7D\u5DF2\u53D6\u6D88", {}, { cause: error });
-    throw new PPDetectionError(
-      "MODEL_DOWNLOAD_FAILED",
-      "\u8BFB\u53D6\u6A21\u578B\u54CD\u5E94\u5931\u8D25",
-      { sourceKind: asset.source.kind },
-      { cause: error }
-    );
+  for (let attempt = 1; ; attempt++) {
+    throwIfAborted3(options.signal);
+    try {
+      bytes = await downloadAttempt(asset, fetcher, options, policy, attempt);
+      break;
+    } catch (error) {
+      throwIfAborted3(options.signal);
+      if (!(error instanceof RetryableDownloadError) || attempt > policy.maxRetries) throw error;
+      await waitForRetry(Math.min(500 * 2 ** (attempt - 1), 4e3), options.signal);
+    }
   }
   const modelDownloadMs = now() - downloadStarted;
   const integrityStarted = now();
   await verifyModelIntegrity(bytes, asset.source, options.signal);
-  return {
-    bytes,
-    timings: {
-      modelDownloadMs,
-      integrityMs: now() - integrityStarted
-    }
-  };
+  return { bytes, timings: { modelDownloadMs, integrityMs: now() - integrityStarted } };
 }
 
 // src/model/source-resolver.ts
@@ -1631,6 +1797,7 @@ function throwIfAborted4(signal) {
 }
 var ModelManager = class {
   fetcher;
+  download;
   cache;
   coordinator;
   lifecycle = new AbortController();
@@ -1639,6 +1806,7 @@ var ModelManager = class {
   disposed = false;
   disposePromise;
   constructor(options = {}) {
+    this.download = resolveDownloadOptions(options.download);
     this.fetcher = options.fetcher;
     this.cache = createCache(options.cache);
     this.coordinator = coordinateCache(this.cache);
@@ -1735,6 +1903,7 @@ var ModelManager = class {
       try {
         loaded = await loadModelAsset(asset, {
           fetcher: this.fetcher,
+          download: this.download,
           signal: options.signal,
           onProgress: options.onProgress
         });
@@ -2219,7 +2388,7 @@ var WorkerBridge = class {
 };
 
 // src/index.ts
-var CURRENT_SDK_VERSION = "0.3.0";
+var CURRENT_SDK_VERSION = "0.3.2";
 function probePPDetectionCapabilities(options = {}) {
   return probeCapabilities(options);
 }
@@ -2344,6 +2513,7 @@ async function createPPDetection(options = {}) {
     simpleManifest(runtimeManifest)
   );
   const modelManager = new ModelManager({
+    download: options.download,
     cache: options.cache === false ? false : options.cache === "memory" ? "memory" : void 0
   });
   let executor;