web-sdk-pp-detection 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -228,6 +228,12 @@ interface PPDetectionFallback {
     readonly variantId: string;
 }
 interface PPDetectionRuntimeInfo {
+    readonly runtimeVersion?: string | null;
+    readonly environment?: Readonly<{
+        userAgent: string | null;
+        platform: string | null;
+        capturedAt: string;
+    }>;
     readonly requestedBackend: BackendPreference;
     readonly backend: Backend;
     readonly precision: Precision;
@@ -252,6 +258,7 @@ interface PPDetectionModelSourceInfo {
     readonly sha256: string;
 }
 interface PPDetectionLoadTimings {
+    readonly modelSource?: "network" | "cache" | "memory";
     readonly modelDownloadMs?: number;
     readonly modelCacheReadMs?: number;
     readonly integrityMs?: number;
@@ -418,6 +425,9 @@ interface OrtInferenceSession {
 interface OrtModule {
     readonly env: {
         readonly wasm?: Record<string, unknown>;
+        readonly versions?: {
+            readonly web?: string;
+        };
     };
     readonly InferenceSession: {
         create(model: ArrayBuffer, options: Record<string, unknown>): Promise<OrtInferenceSession>;
@@ -425,6 +435,7 @@ interface OrtModule {
     readonly Tensor?: new (type: string, data: unknown, dims: readonly number[]) => unknown;
 }
 interface OrtSessionHandle {
+    readonly runtimeVersion?: string | null;
     readonly plan: ExecutionPlan;
     readonly sessionMs: number;
     run(feeds: Record<string, unknown>, options?: {
@@ -522,11 +533,16 @@ interface CacheEstimate {
     readonly entries: number;
 }
 interface ModelCache {
+    readonly scope?: object;
     get(key: string): Promise<ArrayBuffer | undefined>;
     put(key: string, bytes: ArrayBuffer): Promise<void>;
     clearCurrent(key: string): Promise<void>;
     clearAll(): Promise<void>;
     estimate(): Promise<CacheEstimate>;
+    list?(): Promise<readonly {
+        key: string;
+        bytes: number;
+    }[]>;
     close?(): Promise<void> | void;
 }
 
@@ -559,6 +575,7 @@ interface LoadedManagedModel {
 declare class ModelManager {
     private readonly fetcher?;
     private readonly cache;
+    private readonly coordinator;
     private readonly lifecycle;
     private readonly activeLoads;
     private currentKey?;
@@ -569,8 +586,8 @@ declare class ModelManager {
     load(options: LoadManagedModelOptions): Promise<LoadedManagedModel>;
     private loadActive;
     estimate(): Promise<CacheEstimate>;
-    getCacheEstimate(): Promise<CacheEstimate>;
-    clearCurrentModelCache(): Promise<void>;
+    getCacheEstimate(model?: ModelIdentity): Promise<CacheEstimate>;
+    clearCurrentModelCache(model?: ModelIdentity): Promise<void>;
     clearAllCache(): Promise<void>;
     dispose(): Promise<void>;
 }
@@ -583,6 +600,10 @@ declare class MemoryModelCache implements ModelCache {
     clearAll(): Promise<void>;
     estimate(): Promise<CacheEstimate>;
     close(): Promise<void>;
+    list(): Promise<readonly {
+        key: string;
+        bytes: number;
+    }[]>;
 }
 
 interface IndexedDBModelCacheOptions {
@@ -590,6 +611,7 @@ interface IndexedDBModelCacheOptions {
     readonly databaseName?: string;
 }
 declare class IndexedDBModelCache implements ModelCache {
+    readonly scope: object;
     private readonly factory;
     private readonly databaseName;
     private database?;
@@ -600,6 +622,10 @@ declare class IndexedDBModelCache implements ModelCache {
     clearAll(): Promise<void>;
     estimate(): Promise<CacheEstimate>;
     close(): Promise<void>;
+    list(): Promise<readonly {
+        key: string;
+        bytes: number;
+    }[]>;
     private open;
     private request;
 }
@@ -607,7 +633,7 @@ declare class IndexedDBModelCache implements ModelCache {
 declare global {
     var __PPDETECTION_SCRIPT_URL__: string | undefined;
 }
-declare const CURRENT_SDK_VERSION = "0.1.1";
+declare const CURRENT_SDK_VERSION = "0.2.0";
 
 declare function probePPDetectionCapabilities(options?: CapabilityProbeOptions): DetectionCapabilities;
 

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;
   }
@@ -1688,7 +1849,7 @@ 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))
+  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", details, { cause: error });
@@ -1733,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)
@@ -2051,7 +2213,7 @@ var WorkerBridge = class {
 };
 
 // src/index.ts
-var CURRENT_SDK_VERSION = "0.1.1";
+var CURRENT_SDK_VERSION = "0.2.0";
 function probePPDetectionCapabilities(options = {}) {
   return probeCapabilities(options);
 }
@@ -2146,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,7 +2341,6 @@ async function createPPDetection(options = {}) {
   });
   let executor;
   try {
-    const loadStartedAt = now4();
     options.onProgress?.({ phase: "model", status: "start" });
     let modelBytes;
     let actualSource;
@@ -2190,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,
@@ -2205,20 +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 = [];
     const createExecutorForPlan = async (candidatePlan) => {
       options.onProgress?.({ phase: "session", status: "start" });
       let bridge;
+      const sessionStartedAt = now4();
       try {
         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" });
           bridge = new WorkerBridge(worker);
-          await bridge.load(modelBytes.slice(0), candidatePlan, {
+          const metadata = await bridge.load(modelBytes.slice(0), candidatePlan, {
             onProgress: (event) => options.onProgress?.({
               phase: "session",
               status: event.status
@@ -2228,6 +2403,7 @@ async function createPPDetection(options = {}) {
               numThreads: options.ort?.wasm?.numThreads
             }
           });
+          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 {
@@ -2245,7 +2421,7 @@ async function createPPDetection(options = {}) {
           wasmPaths: options.ort?.wasm?.paths,
           numThreads: options.ort?.wasm?.numThreads
         });
-        sessionMs = session.sessionMs;
+        runtimeVersion = session.runtimeVersion ?? null;
         options.onProgress?.({ phase: "session", status: "complete" });
         return {
           run(input, signal) {
@@ -2269,10 +2445,13 @@ async function createPPDetection(options = {}) {
           { 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 = {
@@ -2314,6 +2493,12 @@ async function createPPDetection(options = {}) {
     }
     if (!executor) throw new PPDetectionError("SESSION_CREATE_FAILED", "\u65E0\u6CD5\u521B\u5EFA\u68C0\u6D4B Session");
     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,
@@ -2324,8 +2509,9 @@ async function createPPDetection(options = {}) {
     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(input, signal);
+          return await activeExecutor.run(attemptInput, signal);
         } catch (error) {
           if (options.allowFallback !== true || selectedCandidateIndex < 0 || selectedCandidateIndex >= plan.candidates.length - 1) {
             throw error;
@@ -2350,6 +2536,7 @@ async function createPPDetection(options = {}) {
           runtime.backend = nextPlan.actualBackend;
           runtime.precision = nextPlan.actualPrecision;
           runtime.mode = nextPlan.executionMode;
+          runtime.runtimeVersion = runtimeVersion;
           const fallback = {
             cause: mapped.cause ?? mapped,
             code: mapped.code,
@@ -2381,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) {
@@ -2397,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 };