web-sdk-pp-detection 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -607,7 +607,7 @@ declare class IndexedDBModelCache implements ModelCache {
 declare global {
     var __PPDETECTION_SCRIPT_URL__: string | undefined;
 }
-declare const CURRENT_SDK_VERSION = "0.1.0";
+declare const CURRENT_SDK_VERSION = "0.1.1";
 
 declare function probePPDetectionCapabilities(options?: CapabilityProbeOptions): DetectionCapabilities;
 

package/dist/index.js

@@ -1687,14 +1687,15 @@ function now3() {
 function mapError(error, phase) {
   if (error instanceof PPDetectionError) return error;
   const message = error instanceof Error ? error.message : String(error);
+  const details = { phase, causeMessage: message };
   if (/abort|cancel/i.test(message))
-    return new PPDetectionError("ABORTED", "\u63A8\u7406\u5DF2\u53D6\u6D88", { phase }, { cause: error });
+    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 }
   );
 }
@@ -1852,14 +1853,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 +1877,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 +1896,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 +2051,7 @@ var WorkerBridge = class {
 };
 
 // src/index.ts
-var CURRENT_SDK_VERSION = "0.1.0";
+var CURRENT_SDK_VERSION = "0.1.1";
 function probePPDetectionCapabilities(options = {}) {
   return probeCapabilities(options);
 }
@@ -2178,7 +2177,6 @@ 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" });
@@ -2211,29 +2209,16 @@ async function createPPDetection(options = {}) {
     }
     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;
       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);
+          await bridge.load(modelBytes.slice(0), candidatePlan, {
             onProgress: (event) => options.onProgress?.({
               phase: "session",
               status: event.status
@@ -2243,35 +2228,65 @@ 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 = {
+          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
+        });
+        sessionMs = session.sessionMs;
         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 }
+        );
+      }
+    };
+    let selectedPlan = plan;
+    let sessionMs = 0;
+    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 +2296,6 @@ async function createPPDetection(options = {}) {
         } catch {
         }
         executor = void 0;
-        try {
-          await activeBridge?.dispose();
-        } catch {
-        }
-        activeBridge = void 0;
         if (!hasNext) {
           throw mapped;
         }
@@ -2303,22 +2313,67 @@ async function createPPDetection(options = {}) {
       }
     }
     if (!executor) throw new PPDetectionError("SESSION_CREATE_FAILED", "\u65E0\u6CD5\u521B\u5EFA\u68C0\u6D4B Session");
-    const loadedExecutor = executor;
+    const runtime = {
+      requestedBackend: options.backend ?? "auto",
+      backend: selectedPlan.actualBackend,
+      precision: selectedPlan.actualPrecision,
+      mode: selectedPlan.executionMode,
+      fallbacks,
+      capabilities
+    };
+    let activeExecutor = executor;
+    const fallbackExecutor = {
+      async run(input, signal) {
+        try {
+          return await activeExecutor.run(input, 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;
+          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(),
@@ -2333,10 +2388,6 @@ async function createPPDetection(options = {}) {
       await executor?.dispose();
     } catch {
     }
-    try {
-      await activeBridge?.dispose();
-    } catch {
-    }
     try {
       await modelManager.dispose();
     } catch {