web-sdk-pp-detection 0.1.0 → 0.2.0

package/dist/index.js

@@ -622,7 +622,11 @@ var PPDetectionDetectorImplementation = class {
         original: { width: decoded.width, height: decoded.height }
       },
       model: this.model,
-      runtime: this.runtime,
+      runtime: {
+        ...this.runtime,
+        fallbacks: this.runtime.fallbacks.map((fallback) => ({ ...fallback })),
+        ...this.runtime.environment ? { environment: { ...this.runtime.environment } } : {}
+      },
       timings: {
         decodeMs: decoded.decodeMs,
         preprocessMs,
@@ -1115,8 +1119,84 @@ function adaptModelManifest(manifest) {
   });
 }
 
+// src/cache/coordination.ts
+var CacheCoordinator = class {
+  caches = /* @__PURE__ */ new Map();
+  generation = 0;
+  keys = /* @__PURE__ */ new Map();
+  pending = Promise.resolve();
+  guard(key) {
+    const generation = this.generation;
+    const keyGeneration = this.keys.get(key) ?? 0;
+    this.keys.set(key, keyGeneration);
+    return () => generation === this.generation && keyGeneration === (this.keys.get(key) ?? 0);
+  }
+  run(operation) {
+    const pending = this.pending.then(operation);
+    this.pending = pending.catch(() => void 0);
+    return pending;
+  }
+  clear(key, matches) {
+    if (matches) {
+      for (const [candidate, generation] of this.keys) {
+        if (matches(candidate)) this.keys.set(candidate, generation + 1);
+      }
+    } else if (key === void 0) this.generation += 1;
+    else this.keys.set(key, (this.keys.get(key) ?? 0) + 1);
+    return this.run(async () => {
+      const outcomes = await Promise.allSettled(
+        [...this.caches.keys()].map(async (cache) => {
+          if (matches && cache.list) {
+            for (const entry of await cache.list()) {
+              if (matches(entry.key)) await cache.clearCurrent(entry.key);
+            }
+          } else if (key === void 0) await cache.clearAll();
+          else await cache.clearCurrent(key);
+        })
+      );
+      const failure = outcomes.find((outcome) => outcome.status === "rejected");
+      if (failure?.status === "rejected") throw failure.reason;
+    });
+  }
+  unregister(cache) {
+    const count = this.caches.get(cache) ?? 0;
+    if (count > 1) {
+      this.caches.set(cache, count - 1);
+      return false;
+    }
+    this.caches.delete(cache);
+    return true;
+  }
+};
+var coordinators = /* @__PURE__ */ new WeakMap();
+function coordinateCache(cache) {
+  const scope = cache.scope ?? cache;
+  let coordinator = coordinators.get(scope);
+  if (!coordinator) {
+    coordinator = new CacheCoordinator();
+    coordinators.set(scope, coordinator);
+  }
+  coordinator.caches.set(cache, (coordinator.caches.get(cache) ?? 0) + 1);
+  return coordinator;
+}
+var databaseScopes = /* @__PURE__ */ new WeakMap();
+function databaseScope(factory, name) {
+  let scopes = databaseScopes.get(factory);
+  if (!scopes) {
+    scopes = /* @__PURE__ */ new Map();
+    databaseScopes.set(factory, scopes);
+  }
+  let scope = scopes.get(name);
+  if (!scope) {
+    scope = {};
+    scopes.set(name, scope);
+  }
+  return scope;
+}
+
 // src/cache/indexeddb-cache.ts
 var IndexedDBModelCache = class {
+  scope;
   factory;
   databaseName;
   database;
@@ -1125,6 +1205,7 @@ var IndexedDBModelCache = class {
     if (!factory) throw new Error("\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 IndexedDB");
     this.factory = factory;
     this.databaseName = options.databaseName ?? "web-sdk-pp-detection-models-v1";
+    this.scope = databaseScope(factory, this.databaseName);
   }
   async get(key) {
     const record3 = await this.request(
@@ -1178,6 +1259,24 @@ var IndexedDBModelCache = class {
     (await this.database).close();
     this.database = void 0;
   }
+  async list() {
+    const database = await this.open();
+    return await new Promise((resolve, reject) => {
+      const transaction = database.transaction("models", "readonly");
+      const request = transaction.objectStore("models").openCursor();
+      const entries = [];
+      request.onerror = () => reject(request.error ?? new Error("\u8BFB\u53D6\u7F13\u5B58\u5BB9\u91CF\u5931\u8D25"));
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor) return;
+        const record3 = cursor.value;
+        entries.push({ key: record3.key, bytes: record3.size });
+        cursor.continue();
+      };
+      transaction.oncomplete = () => resolve(entries);
+      transaction.onabort = () => reject(transaction.error ?? new Error("\u7F13\u5B58\u5BB9\u91CF\u4E8B\u52A1\u4E2D\u6B62"));
+    });
+  }
   open() {
     if (this.database) return this.database;
     this.database = new Promise((resolve, reject) => {
@@ -1247,6 +1346,11 @@ var MemoryModelCache = class {
     this.entries.clear();
     return Promise.resolve();
   }
+  list() {
+    return Promise.resolve(
+      [...this.entries].map(([key, bytes]) => ({ key, bytes: bytes.byteLength }))
+    );
+  }
 };
 
 // src/cache/model-cache.ts
@@ -1254,9 +1358,11 @@ var TieredModelCache = class {
   constructor(memory, persistent) {
     this.memory = memory;
     this.persistent = persistent;
+    this.scope = persistent?.scope ?? persistent ?? memory;
   }
   memory;
   persistent;
+  scope;
   async get(key) {
     const memoryValue = await this.memory.get(key);
     if (memoryValue) return memoryValue;
@@ -1279,6 +1385,13 @@ var TieredModelCache = class {
   estimate() {
     return this.persistent?.estimate() ?? this.memory.estimate();
   }
+  async list() {
+    const entries = /* @__PURE__ */ new Map();
+    for (const cache of [this.memory, this.persistent]) {
+      for (const entry of await cache?.list?.() ?? []) entries.set(entry.key, entry);
+    }
+    return [...entries.values()];
+  }
   async close() {
     await this.memory.close?.();
     await this.persistent?.close?.();
@@ -1488,6 +1601,14 @@ function resolveModelAsset(selection, manifest) {
 
 // src/model/model-manager.ts
 var SDK_CACHE_NAMESPACE = "web-sdk-pp-detection:cache-v1";
+function matchesModel(key, model) {
+  try {
+    const parts = JSON.parse(key);
+    return Array.isArray(parts) && parts[0] === SDK_CACHE_NAMESPACE && (model === void 0 || parts[1] === model.id && parts[2] === model.version);
+  } catch {
+    return false;
+  }
+}
 function now2() {
   return globalThis.performance?.now() ?? Date.now();
 }
@@ -1511,6 +1632,7 @@ function throwIfAborted4(signal) {
 var ModelManager = class {
   fetcher;
   cache;
+  coordinator;
   lifecycle = new AbortController();
   activeLoads = /* @__PURE__ */ new Set();
   currentKey;
@@ -1519,6 +1641,7 @@ var ModelManager = class {
   constructor(options = {}) {
     this.fetcher = options.fetcher;
     this.cache = createCache(options.cache);
+    this.coordinator = coordinateCache(this.cache);
   }
   cacheKey(variant3, source2, model = { id: "unknown", version: "unknown" }) {
     return JSON.stringify([
@@ -1557,16 +1680,24 @@ var ModelManager = class {
     const variant3 = resolveModelVariant(manifest, options.variantId);
     const sourceKind2 = options.sourceKind ?? "auto";
     const sources = resolveModelSources(variant3, sourceKind2);
+    const guards = new Map(
+      sources.map((source2) => {
+        const key = this.cacheKey(variant3, source2, manifest.model);
+        return [key, this.coordinator.guard(key)];
+      })
+    );
     const failures = [];
     let lastError;
     for (const source2 of sources) {
       throwIfAborted4(options.signal);
       const asset = { model: manifest.model, variant: variant3, source: source2 };
       const cacheKey = this.cacheKey(variant3, source2, manifest.model);
+      this.currentKey = cacheKey;
+      const canMutate = guards.get(cacheKey);
       const cacheStarted = now2();
       let cached;
       try {
-        cached = await this.cache.get(cacheKey);
+        cached = await this.coordinator.run(() => this.cache.get(cacheKey));
       } catch (error) {
         if (error instanceof PPDetectionError && error.code === "ABORTED") throw error;
         throwIfAborted4(options.signal);
@@ -1577,7 +1708,6 @@ var ModelManager = class {
         const integrityStarted = now2();
         try {
           await verifyModelIntegrity(cached, source2, options.signal);
-          this.currentKey = cacheKey;
           return {
             bytes: cached,
             manifest,
@@ -1591,7 +1721,9 @@ var ModelManager = class {
         } catch (error) {
           if (error instanceof PPDetectionError && error.code === "ABORTED") throw error;
           try {
-            await this.cache.clearCurrent(cacheKey);
+            await this.coordinator.run(async () => {
+              if (canMutate()) await this.cache.clearCurrent(cacheKey);
+            });
           } catch (clearError) {
             if (clearError instanceof PPDetectionError && clearError.code === "ABORTED")
               throw clearError;
@@ -1627,11 +1759,12 @@ var ModelManager = class {
       }
       throwIfAborted4(options.signal);
       try {
-        await this.cache.put(cacheKey, loaded.bytes);
+        await this.coordinator.run(async () => {
+          if (canMutate()) await this.cache.put(cacheKey, loaded.bytes);
+        });
       } catch {
       }
       throwIfAborted4(options.signal);
-      this.currentKey = cacheKey;
       return {
         bytes: loaded.bytes,
         manifest,
@@ -1656,16 +1789,44 @@ var ModelManager = class {
   estimate() {
     return this.getCacheEstimate();
   }
-  getCacheEstimate() {
-    return this.cache.estimate();
+  getCacheEstimate(model) {
+    return this.coordinator.run(async () => {
+      if (!this.cache.list) {
+        if (model)
+          throw new PPDetectionError(
+            "CAPABILITY_UNSUPPORTED",
+            "\u81EA\u5B9A\u4E49\u7F13\u5B58\u9700\u5B9E\u73B0 list \u624D\u80FD\u6309\u6A21\u578B\u4F30\u7B97"
+          );
+        return this.cache.estimate();
+      }
+      const unique = /* @__PURE__ */ new Map();
+      for (const cache of this.coordinator.caches.keys()) {
+        for (const entry of await cache.list?.() ?? []) unique.set(entry.key, entry);
+      }
+      const entries = [...unique.values()].filter((entry) => matchesModel(entry.key, model));
+      return {
+        bytes: entries.reduce((sum, entry) => sum + entry.bytes, 0),
+        entries: entries.length
+      };
+    });
   }
-  async clearCurrentModelCache() {
+  async clearCurrentModelCache(model) {
+    if (model) {
+      if (!model.id || !model.version)
+        throw new PPDetectionError("INVALID_MANIFEST", "\u7F13\u5B58\u6A21\u578B\u8EAB\u4EFD\u5FC5\u987B\u5305\u542B id \u548C version");
+      if (!this.cache.list)
+        throw new PPDetectionError(
+          "CAPABILITY_UNSUPPORTED",
+          "\u81EA\u5B9A\u4E49\u7F13\u5B58\u9700\u5B9E\u73B0 list \u624D\u80FD\u6309\u6A21\u578B\u6E05\u7406"
+        );
+      await this.coordinator.clear(void 0, (key) => matchesModel(key, model));
+      return;
+    }
     if (!this.currentKey) return;
-    await this.cache.clearCurrent(this.currentKey);
+    await this.coordinator.clear(this.currentKey);
   }
   async clearAllCache() {
-    await this.cache.clearAll();
-    this.currentKey = void 0;
+    await this.coordinator.clear(void 0, (key) => matchesModel(key));
   }
   async dispose() {
     if (this.disposePromise) return await this.disposePromise;
@@ -1674,7 +1835,7 @@ var ModelManager = class {
     this.disposePromise = (async () => {
       await Promise.all([...this.activeLoads]);
       this.currentKey = void 0;
-      await this.cache.close?.();
+      if (this.coordinator.unregister(this.cache)) await this.cache.close?.();
     })();
     await this.disposePromise;
   }
@@ -1687,14 +1848,15 @@ function now3() {
 function mapError(error, phase) {
   if (error instanceof PPDetectionError) return error;
   const message = error instanceof Error ? error.message : String(error);
-  if (/abort|cancel/i.test(message))
-    return new PPDetectionError("ABORTED", "\u63A8\u7406\u5DF2\u53D6\u6D88", { phase }, { cause: error });
+  const details = { phase, causeMessage: message };
+  if (error instanceof Error && error.name === "AbortError")
+    return new PPDetectionError("ABORTED", "\u63A8\u7406\u5DF2\u53D6\u6D88", details, { cause: error });
   if (/memory|out.of.memory|allocation/i.test(message))
-    return new PPDetectionError("OUT_OF_MEMORY", "\u8FD0\u884C\u65F6\u5185\u5B58\u4E0D\u8DB3", { phase }, { cause: error });
+    return new PPDetectionError("OUT_OF_MEMORY", "\u8FD0\u884C\u65F6\u5185\u5B58\u4E0D\u8DB3", details, { cause: error });
   return new PPDetectionError(
     phase === "create" ? "SESSION_CREATE_FAILED" : "INFERENCE_FAILED",
     phase === "create" ? "\u521B\u5EFA ONNX Runtime \u4F1A\u8BDD\u5931\u8D25" : "ONNX Runtime \u63A8\u7406\u5931\u8D25",
-    { phase },
+    details,
     { cause: error }
   );
 }
@@ -1732,6 +1894,7 @@ async function createOrtSession(modelBytes, plan, options = {}) {
     return {
       plan,
       sessionMs,
+      runtimeVersion: ort.env.versions?.web ?? null,
       async run(feeds, runOptions = {}) {
         if (disposed) throw new PPDetectionError("DISPOSED", "\u4F1A\u8BDD\u5DF2\u91CA\u653E", { phase: "run" });
         if (runOptions.signal?.aborted)
@@ -1852,14 +2015,13 @@ function probeCapabilities(options = {}) {
 function fail(code, message, details) {
   throw new PPDetectionError(code, message, details);
 }
-function candidatesForBackend(requested, capabilities, allowFallback) {
+function candidatesForBackend(requested, capabilities) {
   if (requested === "wasm") return ["wasm"];
   if (requested === "webgpu")
     return capabilities.webgpu ? ["webgpu"] : fail("CAPABILITY_UNSUPPORTED", "\u8BF7\u6C42\u7684 webgpu \u4E0D\u53EF\u7528", { requestedBackend: requested });
   const available = [];
   if (capabilities.webgpu) available.push("webgpu");
   available.push("wasm");
-  if (!allowFallback) return available.slice(0, 1);
   return available;
 }
 function selectExecutionPlan(options, capabilities, manifest) {
@@ -1877,19 +2039,18 @@ function selectExecutionPlan(options, capabilities, manifest) {
       requestedPrecision
     });
   }
-  const candidates = candidatesForBackend(
-    requestedBackend,
-    capabilities,
-    options.allowFallback === true
-  ).filter((backend) => variant3.backends.includes(backend));
-  if (candidates.length === 0) {
+  const candidates = candidatesForBackend(requestedBackend, capabilities).filter(
+    (backend) => variant3.backends.includes(backend)
+  );
+  const selectedCandidates = options.allowFallback === true ? candidates : candidates.slice(0, 1);
+  if (selectedCandidates.length === 0) {
     fail("CAPABILITY_UNSUPPORTED", "\u6CA1\u6709\u4E0E\u6A21\u578B\u53D8\u4F53\u5339\u914D\u7684\u53EF\u7528\u540E\u7AEF", {
       requestedBackend,
       requestedPrecision,
       availableBackends: variant3.backends
     });
   }
-  const actualBackend = candidates[0];
+  const actualBackend = selectedCandidates[0];
   return {
     variantId: variant3.id,
     requestedBackend,
@@ -1897,7 +2058,7 @@ function selectExecutionPlan(options, capabilities, manifest) {
     requestedPrecision,
     actualPrecision: variant3.precision,
     executionMode,
-    candidates: candidates.map((backend) => ({
+    candidates: selectedCandidates.map((backend) => ({
       variantId: variant3.id,
       backend,
       precision: variant3.precision,
@@ -2052,7 +2213,7 @@ var WorkerBridge = class {
 };
 
 // src/index.ts
-var CURRENT_SDK_VERSION = "0.1.0";
+var CURRENT_SDK_VERSION = "0.2.0";
 function probePPDetectionCapabilities(options = {}) {
   return probeCapabilities(options);
 }
@@ -2147,6 +2308,7 @@ function workerUrl() {
   return new URL("./inference.worker.js", import.meta.url);
 }
 async function createPPDetection(options = {}) {
+  const loadStartedAt = now4();
   if (options.model === void 0 && options.manifest === void 0)
     throw new PPDetectionError("INVALID_MANIFEST", "\u521B\u5EFA PPDetection \u5B9E\u4F8B\u9700\u8981 manifest \u6216 model");
   const capabilities = probeCapabilities();
@@ -2178,9 +2340,7 @@ async function createPPDetection(options = {}) {
     cache: options.cache === false ? false : options.cache === "memory" ? "memory" : void 0
   });
   let executor;
-  let activeBridge;
   try {
-    const loadStartedAt = now4();
     options.onProgress?.({ phase: "model", status: "start" });
     let modelBytes;
     let actualSource;
@@ -2192,10 +2352,17 @@ async function createPPDetection(options = {}) {
         throw new PPDetectionError("MODEL_SOURCE_UNAVAILABLE", "\u6A21\u578B\u53D8\u4F53\u6CA1\u6709\u53EF\u7528\u6765\u6E90", {
           variantId: variant3.id
         });
+      const integrityStartedAt = now4();
       await verifyModelIntegrity(memoryData, source2, options.signal);
+      const integrityMs = now4() - integrityStartedAt;
       modelBytes = memoryData;
       actualSource = source2;
-      loadTimings = { sessionMs: 0, totalMs: now4() - loadStartedAt, integrityMs: 0 };
+      loadTimings = {
+        sessionMs: 0,
+        totalMs: now4() - loadStartedAt,
+        integrityMs,
+        modelSource: "memory"
+      };
     } else {
       const loaded = await modelManager.load({
         manifest: runtimeManifest,
@@ -2207,33 +2374,26 @@ async function createPPDetection(options = {}) {
       modelBytes = loaded.bytes;
       variant3 = loaded.variant;
       actualSource = loaded.source;
-      loadTimings = { ...loaded.timings, sessionMs: 0, totalMs: now4() - loadStartedAt };
+      loadTimings = {
+        ...loaded.timings,
+        sessionMs: 0,
+        totalMs: now4() - loadStartedAt,
+        modelSource: loaded.fromCache ? "cache" : "network"
+      };
     }
     options.onProgress?.({ phase: "model", status: "complete" });
     const fallbacks = [];
-    let selectedPlan = plan;
-    let sessionMs = 0;
-    for (const candidate of plan.candidates) {
-      const candidatePlan = {
-        ...plan,
-        variantId: candidate.variantId,
-        actualBackend: candidate.backend,
-        actualPrecision: candidate.precision,
-        executionMode: candidate.executionMode,
-        candidates: [candidate]
-      };
+    const createExecutorForPlan = async (candidatePlan) => {
       options.onProgress?.({ phase: "session", status: "start" });
+      let bridge;
+      const sessionStartedAt = now4();
       try {
-        if (candidate.executionMode === "worker") {
+        if (candidatePlan.executionMode === "worker") {
           if (typeof Worker !== "function")
             throw new PPDetectionError("CAPABILITY_UNSUPPORTED", "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 Worker");
-          const worker = new Worker(workerUrl(), {
-            type: "module"
-          });
-          const bridge = new WorkerBridge(worker);
-          activeBridge = bridge;
-          const workerModelBytes = modelBytes.slice(0);
-          await bridge.load(workerModelBytes, candidatePlan, {
+          const worker = new Worker(workerUrl(), { type: "module" });
+          bridge = new WorkerBridge(worker);
+          const metadata = await bridge.load(modelBytes.slice(0), candidatePlan, {
             onProgress: (event) => options.onProgress?.({
               phase: "session",
               status: event.status
@@ -2243,35 +2403,69 @@ async function createPPDetection(options = {}) {
               numThreads: options.ort?.wasm?.numThreads
             }
           });
-          executor = {
-            run(input, signal) {
-              return bridge.run(
-                { [input.inputName]: { data: input.data, dims: input.dims } },
-                { signal }
-              );
-            },
-            dispose: () => bridge.dispose()
-          };
-          activeBridge = void 0;
-        } else {
-          const session = await createOrtSession(modelBytes, candidatePlan, {
-            ort: options.ort?.module,
-            wasmPaths: options.ort?.wasm?.paths,
-            numThreads: options.ort?.wasm?.numThreads
-          });
-          sessionMs = session.sessionMs;
-          executor = {
+          runtimeVersion = typeof metadata === "object" && metadata !== null && "runtimeVersion" in metadata && typeof metadata.runtimeVersion === "string" ? metadata.runtimeVersion : null;
+          const activeBridge = bridge;
+          options.onProgress?.({ phase: "session", status: "complete" });
+          return {
             run(input, signal) {
-              return session.run(
+              return activeBridge.run(
                 { [input.inputName]: { data: input.data, dims: input.dims } },
                 { signal }
               );
             },
-            dispose: () => session.dispose()
+            dispose: () => activeBridge.dispose()
           };
         }
-        selectedPlan = candidatePlan;
+        const session = await createOrtSession(modelBytes, candidatePlan, {
+          ort: options.ort?.module,
+          wasmPaths: options.ort?.wasm?.paths,
+          numThreads: options.ort?.wasm?.numThreads
+        });
+        runtimeVersion = session.runtimeVersion ?? null;
         options.onProgress?.({ phase: "session", status: "complete" });
+        return {
+          run(input, signal) {
+            return session.run(
+              { [input.inputName]: { data: input.data, dims: input.dims } },
+              { signal }
+            );
+          },
+          dispose: () => session.dispose()
+        };
+      } catch (error) {
+        try {
+          await bridge?.dispose();
+        } catch {
+        }
+        if (error instanceof PPDetectionError) throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        throw new PPDetectionError(
+          "SESSION_CREATE_FAILED",
+          "\u521B\u5EFA ONNX Runtime \u4F1A\u8BDD\u5931\u8D25",
+          { phase: "create", causeMessage: message },
+          { cause: error }
+        );
+      } finally {
+        sessionMs += now4() - sessionStartedAt;
+      }
+    };
+    let selectedPlan = plan;
+    let sessionMs = 0;
+    let runtimeVersion = null;
+    let selectedCandidateIndex = -1;
+    for (const [candidateIndex, candidate] of plan.candidates.entries()) {
+      const candidatePlan = {
+        ...plan,
+        variantId: candidate.variantId,
+        actualBackend: candidate.backend,
+        actualPrecision: candidate.precision,
+        executionMode: candidate.executionMode,
+        candidates: [candidate]
+      };
+      try {
+        executor = await createExecutorForPlan(candidatePlan);
+        selectedPlan = candidatePlan;
+        selectedCandidateIndex = candidateIndex;
         break;
       } catch (error) {
         const mapped = error instanceof PPDetectionError ? error : new PPDetectionError("SESSION_CREATE_FAILED", String(error));
@@ -2281,11 +2475,6 @@ async function createPPDetection(options = {}) {
         } catch {
         }
         executor = void 0;
-        try {
-          await activeBridge?.dispose();
-        } catch {
-        }
-        activeBridge = void 0;
         if (!hasNext) {
           throw mapped;
         }
@@ -2303,22 +2492,75 @@ async function createPPDetection(options = {}) {
       }
     }
     if (!executor) throw new PPDetectionError("SESSION_CREATE_FAILED", "\u65E0\u6CD5\u521B\u5EFA\u68C0\u6D4B Session");
-    const loadedExecutor = executor;
+    const runtime = {
+      runtimeVersion,
+      environment: {
+        userAgent: globalThis.navigator?.userAgent ?? null,
+        platform: globalThis.navigator?.platform ?? null,
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      requestedBackend: options.backend ?? "auto",
+      backend: selectedPlan.actualBackend,
+      precision: selectedPlan.actualPrecision,
+      mode: selectedPlan.executionMode,
+      fallbacks,
+      capabilities
+    };
+    let activeExecutor = executor;
+    const fallbackExecutor = {
+      async run(input, signal) {
+        const attemptInput = runtime.mode === "worker" && options.allowFallback === true && selectedCandidateIndex < plan.candidates.length - 1 ? { ...input, data: input.data.slice() } : input;
+        try {
+          return await activeExecutor.run(attemptInput, signal);
+        } catch (error) {
+          if (options.allowFallback !== true || selectedCandidateIndex < 0 || selectedCandidateIndex >= plan.candidates.length - 1) {
+            throw error;
+          }
+          const failedCandidate = plan.candidates[selectedCandidateIndex];
+          const mapped = error instanceof PPDetectionError ? error : new PPDetectionError("INFERENCE_FAILED", String(error), {}, { cause: error });
+          if (mapped.code === "ABORTED") throw mapped;
+          const nextCandidate = plan.candidates[selectedCandidateIndex + 1];
+          const nextPlan = {
+            ...plan,
+            variantId: nextCandidate.variantId,
+            actualBackend: nextCandidate.backend,
+            actualPrecision: nextCandidate.precision,
+            executionMode: nextCandidate.executionMode,
+            candidates: [nextCandidate]
+          };
+          await activeExecutor.dispose();
+          const nextExecutor = await createExecutorForPlan(nextPlan);
+          activeExecutor = nextExecutor;
+          selectedCandidateIndex += 1;
+          selectedPlan = nextPlan;
+          runtime.backend = nextPlan.actualBackend;
+          runtime.precision = nextPlan.actualPrecision;
+          runtime.mode = nextPlan.executionMode;
+          runtime.runtimeVersion = runtimeVersion;
+          const fallback = {
+            cause: mapped.cause ?? mapped,
+            code: mapped.code,
+            message: mapped.message,
+            precision: failedCandidate.precision,
+            provider: failedCandidate.backend,
+            stage: "inference",
+            variantId: failedCandidate.variantId
+          };
+          fallbacks.push(fallback);
+          options.onProgress?.({ phase: "fallback", status: "complete", fallback });
+          return activeExecutor.run(input, signal);
+        }
+      },
+      dispose: () => activeExecutor.dispose()
+    };
     loadTimings = { ...loadTimings, sessionMs, totalMs: now4() - loadStartedAt };
     const detector = new PPDetectionDetectorImplementation({
       capabilities,
       manifest: runtimeManifest,
       model: modelInfo(runtimeManifest, variant3.id, actualSource),
-      runtime: {
-        requestedBackend: options.backend ?? "auto",
-        backend: selectedPlan.actualBackend,
-        precision: selectedPlan.actualPrecision,
-        mode: selectedPlan.executionMode,
-        fallbacks,
-        capabilities
-      },
+      runtime,
       loadTimings,
-      loadExecutor: () => Promise.resolve(loadedExecutor),
+      loadExecutor: () => Promise.resolve(fallbackExecutor),
       onProgress: options.onProgress,
       clearCurrentModelCache: () => modelManager.clearCurrentModelCache(),
       clearAllCache: () => modelManager.clearAllCache(),
@@ -2326,6 +2568,7 @@ async function createPPDetection(options = {}) {
       disposeResources: () => modelManager.dispose()
     });
     await detector.load({ signal: options.signal });
+    loadTimings.totalMs = now4() - loadStartedAt;
     options.onProgress?.({ phase: "ready", status: "complete" });
     return detector;
   } catch (error) {
@@ -2333,10 +2576,6 @@ async function createPPDetection(options = {}) {
       await executor?.dispose();
     } catch {
     }
-    try {
-      await activeBridge?.dispose();
-    } catch {
-    }
     try {
       await modelManager.dispose();
     } catch {
@@ -2346,8 +2585,11 @@ async function createPPDetection(options = {}) {
 }
 async function clearModelCache() {
   const manager = new ModelManager();
-  await manager.clearAllCache();
-  await manager.dispose();
+  try {
+    await manager.clearAllCache();
+  } finally {
+    await manager.dispose();
+  }
 }
 
 export { CURRENT_SDK_VERSION, IndexedDBModelCache, MemoryModelCache, ModelManager, PPDetectionError, adaptModelManifest, clearModelCache, createOrtSession, createPPDetection, loadModelAsset, parseDetectionManifest, parseModelManifest, probeCapabilities, probePPDetectionCapabilities, resolveModelAsset, selectExecutionPlan };