web-sdk-pp-detection 0.1.0 → 0.2.0

package/dist/browser-global.js

@@ -14258,7 +14258,11 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
           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,
@@ -14751,8 +14755,84 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
     });
   }
 
+  // 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;
@@ -14761,6 +14841,7 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
       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(
@@ -14814,6 +14895,24 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
       (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) => {
@@ -14883,6 +14982,11 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
       this.entries.clear();
       return Promise.resolve();
     }
+    list() {
+      return Promise.resolve(
+        [...this.entries].map(([key, bytes]) => ({ key, bytes: bytes.byteLength }))
+      );
+    }
   };
 
   // src/cache/model-cache.ts
@@ -14890,9 +14994,11 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
     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;
@@ -14915,6 +15021,13 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
     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?.();
@@ -15124,6 +15237,14 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
 
   // 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();
   }
@@ -15147,6 +15268,7 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
   var ModelManager = class {
     fetcher;
     cache;
+    coordinator;
     lifecycle = new AbortController();
     activeLoads = /* @__PURE__ */ new Set();
     currentKey;
@@ -15155,6 +15277,7 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
     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([
@@ -15193,16 +15316,24 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
       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);
@@ -15213,7 +15344,6 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
           const integrityStarted = now2();
           try {
             await verifyModelIntegrity(cached, source2, options.signal);
-            this.currentKey = cacheKey;
             return {
               bytes: cached,
               manifest,
@@ -15227,7 +15357,9 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
           } 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;
@@ -15263,11 +15395,12 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
         }
         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,
@@ -15292,16 +15425,44 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
     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;
@@ -15310,7 +15471,7 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
       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;
     }
@@ -15323,14 +15484,15 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
   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 }
     );
   }
@@ -15368,6 +15530,7 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
       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)
@@ -15488,14 +15651,13 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
   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) {
@@ -15513,19 +15675,18 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
         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,
@@ -15533,7 +15694,7 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
       requestedPrecision,
       actualPrecision: variant3.precision,
       executionMode,
-      candidates: candidates.map((backend) => ({
+      candidates: selectedCandidates.map((backend) => ({
         variantId: variant3.id,
         backend,
         precision: variant3.precision,
@@ -15688,7 +15849,7 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
   };
 
   // src/index.ts
-  var CURRENT_SDK_VERSION = "0.1.0";
+  var CURRENT_SDK_VERSION = "0.2.0";
   function probePPDetectionCapabilities(options = {}) {
     return probeCapabilities(options);
   }
@@ -15783,6 +15944,7 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
     return new URL("./inference.worker.js", (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('browser-global.js', document.baseURI).href));
   }
   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();
@@ -15814,9 +15976,7 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
       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;
@@ -15828,10 +15988,17 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
           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,
@@ -15843,33 +16010,26 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
         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
@@ -15879,35 +16039,69 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
                 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));
@@ -15917,11 +16111,6 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
           } catch {
           }
           executor = void 0;
-          try {
-            await activeBridge?.dispose();
-          } catch {
-          }
-          activeBridge = void 0;
           if (!hasNext) {
             throw mapped;
           }
@@ -15939,22 +16128,75 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
         }
       }
       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(),
@@ -15962,6 +16204,7 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
         disposeResources: () => modelManager.dispose()
       });
       await detector.load({ signal: options.signal });
+      loadTimings.totalMs = now4() - loadStartedAt;
       options.onProgress?.({ phase: "ready", status: "complete" });
       return detector;
     } catch (error) {
@@ -15969,10 +16212,6 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
         await executor?.dispose();
       } catch {
       }
-      try {
-        await activeBridge?.dispose();
-      } catch {
-      }
       try {
         await modelManager.dispose();
       } catch {
@@ -15982,8 +16221,11 @@ ${u}`, c = n.createShaderModule({ code: d, label: e.name });
   }
   async function clearModelCache() {
     const manager = new ModelManager();
-    await manager.clearAllCache();
-    await manager.dispose();
+    try {
+      await manager.clearAllCache();
+    } finally {
+      await manager.dispose();
+    }
   }
 
   // src/browser-global.ts