web-sdk-pp-detection 0.1.0

package/dist/index.js

@@ -0,0 +1,2355 @@
+// src/errors.ts
+var PPDetectionError = class extends Error {
+  constructor(code, message, details = {}, options) {
+    super(message, options);
+    this.code = code;
+    this.details = details;
+    this.name = "PPDetectionError";
+  }
+  code;
+  details;
+};
+
+// src/input/decode-image.ts
+function nowDefault() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw new PPDetectionError("ABORTED", "\u56FE\u7247\u89E3\u7801\u5DF2\u53D6\u6D88", { reason: signal.reason });
+  }
+}
+function isImageDataLike(value) {
+  return typeof value === "object" && value !== null && "width" in value && "height" in value && ("data" in value && value.data instanceof Uint8ClampedArray || "rgba" in value && value.rgba instanceof Uint8ClampedArray);
+}
+function validateRaster(raster) {
+  if (!Number.isInteger(raster.width) || !Number.isInteger(raster.height) || raster.width <= 0 || raster.height <= 0 || raster.rgba.length !== raster.width * raster.height * 4) {
+    throw new PPDetectionError("INVALID_INPUT", "\u56FE\u7247\u5C3A\u5BF8\u6216 RGBA \u6570\u636E\u65E0\u6548", {
+      width: raster.width,
+      height: raster.height,
+      rgbaLength: raster.rgba.length
+    });
+  }
+  return raster;
+}
+function dimensions(source2) {
+  return {
+    width: source2.naturalWidth ?? source2.videoWidth ?? source2.displayWidth ?? source2.width ?? 0,
+    height: source2.naturalHeight ?? source2.videoHeight ?? source2.displayHeight ?? source2.height ?? 0
+  };
+}
+function defaultCreateCanvas(width, height) {
+  if (typeof OffscreenCanvas === "function") return new OffscreenCanvas(width, height);
+  if (typeof document === "object") {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    return canvas;
+  }
+  throw new PPDetectionError("INVALID_INPUT", "\u5F53\u524D\u73AF\u5883\u6CA1\u6709\u53EF\u7528\u7684 Canvas 2D \u5B9E\u73B0");
+}
+function invalidDecode(error) {
+  if (error instanceof PPDetectionError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  const cors = typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "SecurityError" || /cors|cross.origin|taint|security/i.test(message);
+  return new PPDetectionError(
+    "INVALID_INPUT",
+    cors ? "\u65E0\u6CD5\u4ECE\u5A92\u4F53\u8BFB\u53D6\u50CF\u7D20\uFF0C\u8BF7\u68C0\u67E5 CORS \u54CD\u5E94\u5934\u548C Canvas \u8DE8\u57DF\u9650\u5236" : "\u65E0\u6CD5\u89E3\u7801\u6216\u8BFB\u53D6\u56FE\u7247\u50CF\u7D20",
+    { cors, causeMessage: message },
+    { cause: error }
+  );
+}
+async function decodeImageSource(input, environment = {}) {
+  const clock = environment.now ?? nowDefault;
+  const startedAt = clock();
+  throwIfAborted(environment.signal);
+  if (isImageDataLike(input)) {
+    const raster = validateRaster({
+      width: input.width,
+      height: input.height,
+      rgba: new Uint8ClampedArray(input.data ?? input.rgba)
+    });
+    return { ...raster, decodeMs: Math.max(0, clock() - startedAt) };
+  }
+  let ownedBitmap;
+  try {
+    let source2;
+    if (typeof Blob !== "undefined" && input instanceof Blob) {
+      const createBitmap = environment.createImageBitmap ?? globalThis.createImageBitmap;
+      if (typeof createBitmap !== "function") {
+        throw new PPDetectionError("INVALID_INPUT", "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 Blob \u56FE\u7247\u89E3\u7801");
+      }
+      ownedBitmap = await createBitmap(input);
+      source2 = ownedBitmap;
+    } else {
+      source2 = input;
+    }
+    throwIfAborted(environment.signal);
+    const { width, height } = dimensions(source2);
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+      throw new PPDetectionError("INVALID_INPUT", "\u56FE\u7247\u5BBD\u9AD8\u5FC5\u987B\u662F\u6B63\u6574\u6570", { width, height });
+    }
+    const canvas = (environment.createCanvas ?? defaultCreateCanvas)(width, height);
+    const context = canvas.getContext("2d", { willReadFrequently: true });
+    if (!context) throw new PPDetectionError("INVALID_INPUT", "\u65E0\u6CD5\u521B\u5EFA Canvas 2D \u4E0A\u4E0B\u6587");
+    context.drawImage(source2, 0, 0);
+    const rgba = new Uint8ClampedArray(context.getImageData(0, 0, width, height).data);
+    throwIfAborted(environment.signal);
+    const raster = validateRaster({ width, height, rgba });
+    return { ...raster, decodeMs: Math.max(0, clock() - startedAt) };
+  } catch (error) {
+    throw invalidDecode(error);
+  } finally {
+    ownedBitmap?.close?.();
+  }
+}
+
+// src/detection/nms.ts
+function area(box) {
+  return Math.max(0, box.xMax - box.xMin) * Math.max(0, box.yMax - box.yMin);
+}
+function intersectionOverUnion(left, right) {
+  const intersection = Math.max(0, Math.min(left.xMax, right.xMax) - Math.max(left.xMin, right.xMin)) * Math.max(0, Math.min(left.yMax, right.yMax) - Math.max(left.yMin, right.yMin));
+  const union = area(left) + area(right) - intersection;
+  return union <= 0 ? 0 : intersection / union;
+}
+function nonMaximumSuppression(candidates, iouThreshold) {
+  const sorted = [...candidates].sort(
+    (left, right) => right.score - left.score || left.index - right.index
+  );
+  const selected = [];
+  for (const candidate of sorted) {
+    const suppressed = selected.some(
+      (kept) => kept.classId === candidate.classId && intersectionOverUnion(kept.box, candidate.box) > iouThreshold
+    );
+    if (!suppressed) selected.push(candidate);
+  }
+  return selected;
+}
+
+// src/detection/decode-output.ts
+function tensorMap(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new PPDetectionError("INFERENCE_FAILED", "\u6A21\u578B\u8F93\u51FA\u5FC5\u987B\u662F\u5F20\u91CF\u6620\u5C04");
+  }
+  const outputs = value;
+  for (const [name, tensor3] of Object.entries(outputs)) {
+    const data = tensor3?.data;
+    const dims = tensor3?.dims;
+    if (typeof tensor3 !== "object" || tensor3 === null || !("data" in tensor3) || !("dims" in tensor3) || !Array.isArray(dims) || dims.length === 0 || !dims.every((dimension) => Number.isInteger(dimension) && dimension >= 0) || typeof data?.length !== "number" || !Number.isSafeInteger(data.length) || data.length !== dims.reduce((size, dimension) => size * Number(dimension), 1)) {
+      throw new PPDetectionError("INFERENCE_FAILED", "\u6A21\u578B\u8F93\u51FA\u5F20\u91CF\u7ED3\u6784\u65E0\u6548", { name });
+    }
+  }
+  return outputs;
+}
+function thresholdFor(classId, options) {
+  const label = options.labels[classId] ?? String(classId);
+  return options.classThresholds?.[label] ?? options.scoreThreshold;
+}
+function sigmoid(value) {
+  return value >= 0 ? 1 / (1 + Math.exp(-value)) : Math.exp(value) / (1 + Math.exp(value));
+}
+function matchesContract(tensor3, contract) {
+  return tensor3.dims !== void 0 && tensor3.dims.length === contract.shape.length && tensor3.dims.every(
+    (dimension, index) => contract.shape[index] === -1 || dimension === contract.shape[index]
+  );
+}
+function declaredTensor(outputs, contracts, predicate) {
+  if (contracts === void 0) return void 0;
+  const matches = contracts.filter(predicate).map((contract) => {
+    const tensor3 = outputs[contract.name];
+    return tensor3 && matchesContract(tensor3, contract) ? tensor3 : void 0;
+  }).filter((tensor3) => tensor3 !== void 0);
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function matrixCandidates(outputs, options) {
+  let output;
+  if (options.outputs !== void 0) {
+    output = declaredTensor(outputs, options.outputs, (tensor3) => tensor3.shape.at(-1) === 6);
+  } else {
+    output = Object.entries(outputs).find(([, tensor3]) => tensor3.dims?.at(-1) === 6)?.[1];
+  }
+  if (!output) return void 0;
+  const data = output.data;
+  const candidates = [];
+  for (let offset = 0, index = 0; offset + 5 < data.length; offset += 6, index += 1) {
+    const classId = Math.trunc(Number(data[offset]));
+    const score = Number(data[offset + 1]);
+    if (!Number.isFinite(score) || score < thresholdFor(classId, options)) continue;
+    const coordinates = [2, 3, 4, 5].map((item) => Number(data[offset + item]));
+    if (!coordinates.every(Number.isFinite)) continue;
+    const normalized = options.matrixCoordinates === "normalized";
+    candidates.push({
+      index,
+      classId,
+      score,
+      box: {
+        xMin: coordinates[0] * (normalized ? options.transform.inputWidth : 1),
+        yMin: coordinates[1] * (normalized ? options.transform.inputHeight : 1),
+        xMax: coordinates[2] * (normalized ? options.transform.inputWidth : 1),
+        yMax: coordinates[3] * (normalized ? options.transform.inputHeight : 1)
+      }
+    });
+  }
+  return candidates;
+}
+function findOutput(outputs, expression) {
+  return Object.entries(outputs).find(([name]) => expression.test(name))?.[1];
+}
+function queryCandidates(outputs, options) {
+  const boxes = options.outputs ? declaredTensor(outputs, options.outputs, (tensor3) => tensor3.shape.at(-1) === 4) : findOutput(outputs, /pred.*box|boxes/i);
+  const declaredLogitCandidates = options.outputs?.filter(
+    (tensor3) => tensor3.shape.at(-1) !== 4 && tensor3.shape.at(-1) !== 6 && tensor3.shape.length >= 2
+  );
+  const logits = options.outputs ? declaredTensor(
+    outputs,
+    declaredLogitCandidates,
+    (tensor3) => tensor3.shape.at(-1) === options.labels.length && !/(?:order|mask|aux)/i.test(tensor3.name)
+  ) ?? (declaredLogitCandidates?.length === 1 ? declaredTensor(outputs, declaredLogitCandidates, () => true) : void 0) : findOutput(outputs, /logit|score/i);
+  if (!logits || !boxes) return void 0;
+  const boxCount = Math.floor(boxes.data.length / 4);
+  if (boxCount === 0) return [];
+  const declaredClasses = logits.dims?.at(-1) ?? Math.floor(logits.data.length / boxCount);
+  const classes = Math.min(declaredClasses, options.labels.length);
+  if (classes <= 0) return [];
+  const candidates = [];
+  for (let query = 0; query < boxCount; query += 1) {
+    let classId = 0;
+    let score = -Infinity;
+    for (let candidateClass = 0; candidateClass < classes; candidateClass += 1) {
+      const candidateScore = sigmoid(Number(logits.data[query * declaredClasses + candidateClass]));
+      if (candidateScore > score) {
+        score = candidateScore;
+        classId = candidateClass;
+      }
+    }
+    if (score < thresholdFor(classId, options)) continue;
+    const offset = query * 4;
+    const raw = [
+      Number(boxes.data[offset]),
+      Number(boxes.data[offset + 1]),
+      Number(boxes.data[offset + 2]),
+      Number(boxes.data[offset + 3])
+    ];
+    if (!raw.every(Number.isFinite)) continue;
+    const normalized = options.queryCoordinates !== "pixels";
+    const xScale = normalized ? options.transform.inputWidth : 1;
+    const yScale = normalized ? options.transform.inputHeight : 1;
+    const xMin = options.queryBoxFormat === "xyxy" ? raw[0] : raw[0] - raw[2] / 2;
+    const yMin = options.queryBoxFormat === "xyxy" ? raw[1] : raw[1] - raw[3] / 2;
+    const xMax = options.queryBoxFormat === "xyxy" ? raw[2] : raw[0] + raw[2] / 2;
+    const yMax = options.queryBoxFormat === "xyxy" ? raw[3] : raw[1] + raw[3] / 2;
+    candidates.push({
+      index: query,
+      classId,
+      score,
+      box: {
+        xMin: xMin * xScale,
+        yMin: yMin * yScale,
+        xMax: xMax * xScale,
+        yMax: yMax * yScale
+      }
+    });
+  }
+  return candidates;
+}
+function clamp(value, minimum, maximum) {
+  return Math.min(maximum, Math.max(minimum, value));
+}
+function restoreBox(box, transform) {
+  const scaleX = transform.scaleX ?? transform.scale;
+  const scaleY = transform.scaleY ?? transform.scale;
+  const xMin = clamp((box.xMin - transform.padLeft) / scaleX, 0, transform.originalWidth);
+  const yMin = clamp((box.yMin - transform.padTop) / scaleY, 0, transform.originalHeight);
+  const xMax = clamp((box.xMax - transform.padLeft) / scaleX, 0, transform.originalWidth);
+  const yMax = clamp((box.yMax - transform.padTop) / scaleY, 0, transform.originalHeight);
+  if (xMax <= xMin || yMax <= yMin) return void 0;
+  return {
+    x: xMin,
+    y: yMin,
+    width: xMax - xMin,
+    height: yMax - yMin,
+    xMin,
+    yMin,
+    xMax,
+    yMax
+  };
+}
+function decodeDetectionOutputs(outputValue, options) {
+  const outputs = tensorMap(outputValue);
+  const candidates = matrixCandidates(outputs, options) ?? queryCandidates(outputs, options);
+  if (!candidates) {
+    throw new PPDetectionError("INFERENCE_FAILED", "\u4E0D\u652F\u6301\u5F53\u524D\u6A21\u578B\u7684\u68C0\u6D4B\u8F93\u51FA\u7B7E\u540D", {
+      outputs: Object.keys(outputs)
+    });
+  }
+  const restored = candidates.flatMap((candidate) => {
+    const box = restoreBox(candidate.box, options.transform);
+    return box ? [{ ...candidate, box }] : [];
+  });
+  return nonMaximumSuppression(restored, options.iouThreshold).map((candidate) => ({
+    index: candidate.index,
+    classId: candidate.classId,
+    labelId: candidate.classId,
+    label: options.labels[candidate.classId] ?? String(candidate.classId),
+    score: candidate.score,
+    box: candidate.box,
+    polygon: [
+      { x: candidate.box.xMin, y: candidate.box.yMin },
+      { x: candidate.box.xMax, y: candidate.box.yMin },
+      { x: candidate.box.xMax, y: candidate.box.yMax },
+      { x: candidate.box.xMin, y: candidate.box.yMax }
+    ]
+  }));
+}
+
+// src/detection/preprocess.ts
+function sampleChannel(raster, x, y, channel) {
+  const sourceX = Math.min(raster.width - 1, Math.max(0, x));
+  const sourceY = Math.min(raster.height - 1, Math.max(0, y));
+  return raster.rgba[(sourceY * raster.width + sourceX) * 4 + channel];
+}
+function bilinearChannel(raster, targetX, targetY, resizedWidth, resizedHeight, channel) {
+  const sourceX = (targetX + 0.5) * raster.width / resizedWidth - 0.5;
+  const sourceY = (targetY + 0.5) * raster.height / resizedHeight - 0.5;
+  const x0 = Math.floor(sourceX);
+  const y0 = Math.floor(sourceY);
+  const dx = sourceX - x0;
+  const dy = sourceY - y0;
+  const top = sampleChannel(raster, x0, y0, channel) * (1 - dx) + sampleChannel(raster, x0 + 1, y0, channel) * dx;
+  const bottom = sampleChannel(raster, x0, y0 + 1, channel) * (1 - dx) + sampleChannel(raster, x0 + 1, y0 + 1, channel) * dx;
+  return top * (1 - dy) + bottom * dy;
+}
+var BICUBIC_PRECISION_BITS = 22;
+var BICUBIC_PRECISION = 1 << BICUBIC_PRECISION_BITS;
+var BICUBIC_ROUNDING = 1 << BICUBIC_PRECISION_BITS - 1;
+function bicubicFilter(value) {
+  const x = Math.abs(value);
+  if (x < 1) return ((-0.5 + 2) * x - (-0.5 + 3)) * x * x + 1;
+  if (x < 2) return (((x - 5) * x + 8) * x - 4) * -0.5;
+  return 0;
+}
+function createBicubicAxis(inputSize, outputSize) {
+  const scale = inputSize / outputSize;
+  const filterScale = Math.max(scale, 1);
+  const support = 2 * filterScale;
+  const axis = [];
+  for (let output = 0; output < outputSize; output += 1) {
+    const center = (output + 0.5) * scale;
+    let start = Math.trunc(center - support + 0.5);
+    if (start < 0) start = 0;
+    let end = Math.trunc(center + support + 0.5);
+    if (end > inputSize) end = inputSize;
+    end -= start;
+    const weights = [];
+    let total = 0;
+    for (let index = 0; index < end; index += 1) {
+      const weight = bicubicFilter((index + start - center + 0.5) / filterScale);
+      weights.push(weight);
+      total += weight;
+    }
+    if (total !== 0) {
+      for (let index = 0; index < weights.length; index += 1) {
+        weights[index] = weights[index] / total;
+      }
+    }
+    axis.push({
+      bounds: [start, end],
+      coefficients: weights.map(
+        (weight) => Math.trunc(
+          weight < 0 ? -0.5 + weight * BICUBIC_PRECISION : 0.5 + weight * BICUBIC_PRECISION
+        )
+      )
+    });
+  }
+  return {
+    bounds: axis.map(({ bounds }) => bounds),
+    coefficients: axis.map(({ coefficients }) => coefficients)
+  };
+}
+function clipBicubic(value) {
+  const rounded = value >> BICUBIC_PRECISION_BITS;
+  return Math.max(0, Math.min(255, rounded));
+}
+function bicubicChannel(raster, resizedWidth, resizedHeight, channel) {
+  const horizontal = createBicubicAxis(raster.width, resizedWidth);
+  const vertical = createBicubicAxis(raster.height, resizedHeight);
+  const intermediate = new Uint8Array(raster.height * resizedWidth);
+  for (let y = 0; y < raster.height; y += 1) {
+    for (let x = 0; x < resizedWidth; x += 1) {
+      const [start, count] = horizontal.bounds[x];
+      const coefficients = horizontal.coefficients[x];
+      let sum = BICUBIC_ROUNDING;
+      for (let index = 0; index < count; index += 1) {
+        sum += raster.rgba[(y * raster.width + start + index) * 4 + channel] * coefficients[index];
+      }
+      intermediate[y * resizedWidth + x] = clipBicubic(sum);
+    }
+  }
+  const output = new Uint8Array(resizedWidth * resizedHeight);
+  for (let y = 0; y < resizedHeight; y += 1) {
+    const [start, count] = vertical.bounds[y];
+    const coefficients = vertical.coefficients[y];
+    for (let x = 0; x < resizedWidth; x += 1) {
+      let sum = BICUBIC_ROUNDING;
+      for (let index = 0; index < count; index += 1) {
+        sum += intermediate[(start + index) * resizedWidth + x] * coefficients[index];
+      }
+      output[y * resizedWidth + x] = clipBicubic(sum);
+    }
+  }
+  return output;
+}
+function preprocessImage(raster, preprocessing) {
+  const inputWidth = preprocessing.size.width;
+  const inputHeight = preprocessing.size.height;
+  const doResize = preprocessing.doResize ?? true;
+  if (!doResize && (raster.width > inputWidth || raster.height > inputHeight)) {
+    throw new PPDetectionError("INVALID_INPUT", "\u7981\u7528\u7F29\u653E\u65F6\uFF0C\u8F93\u5165\u56FE\u50CF\u5C3A\u5BF8\u4E0D\u80FD\u8D85\u8FC7\u6A21\u578B\u8F93\u5165\u5C3A\u5BF8", {
+      inputSize: { width: inputWidth, height: inputHeight },
+      imageSize: { width: raster.width, height: raster.height }
+    });
+  }
+  const resizeMode2 = preprocessing.resizeMode ?? "letterbox";
+  const scale = doResize ? Math.min(inputWidth / raster.width, inputHeight / raster.height) : 1;
+  const resizedWidth = doResize ? resizeMode2 === "stretch" ? inputWidth : Math.max(1, Math.min(inputWidth, Math.round(raster.width * scale))) : Math.min(inputWidth, raster.width);
+  const resizedHeight = doResize ? resizeMode2 === "stretch" ? inputHeight : Math.max(1, Math.min(inputHeight, Math.round(raster.height * scale))) : Math.min(inputHeight, raster.height);
+  const scaleX = resizedWidth / raster.width;
+  const scaleY = resizedHeight / raster.height;
+  const padLeft = resizeMode2 === "stretch" ? 0 : Math.floor((inputWidth - resizedWidth) / 2);
+  const padTop = resizeMode2 === "stretch" ? 0 : Math.floor((inputHeight - resizedHeight) / 2);
+  const plane = inputWidth * inputHeight;
+  const data = new Float32Array(plane * 3);
+  const normalize = preprocessing.doNormalize ?? true;
+  const rescale = preprocessing.doRescale ?? true;
+  const mean = normalize ? preprocessing.mean ?? [0, 0, 0] : [0, 0, 0];
+  const std = normalize ? preprocessing.std ?? [1, 1, 1] : [1, 1, 1];
+  const interpolation2 = preprocessing.interpolation ?? "bilinear";
+  for (let channel = 0; channel < 3; channel += 1) {
+    const padding = normalize && mean[channel] !== 0 ? -mean[channel] / std[channel] : 0;
+    data.fill(padding, channel * plane, (channel + 1) * plane);
+    const bicubic = doResize && interpolation2 === "bicubic" ? bicubicChannel(raster, resizedWidth, resizedHeight, channel) : void 0;
+    for (let y = 0; y < resizedHeight; y += 1) {
+      for (let x = 0; x < resizedWidth; x += 1) {
+        const pixel = bicubic ? bicubic[y * resizedWidth + x] : doResize ? bilinearChannel(raster, x, y, resizedWidth, resizedHeight, channel) : sampleChannel(raster, x, y, channel);
+        const scaled = rescale ? pixel * preprocessing.rescaleFactor : pixel;
+        data[channel * plane + (y + padTop) * inputWidth + x + padLeft] = normalize ? (scaled - mean[channel]) / std[channel] : scaled;
+      }
+    }
+  }
+  return {
+    data,
+    dims: [1, 3, inputHeight, inputWidth],
+    transform: {
+      inputWidth,
+      inputHeight,
+      originalWidth: raster.width,
+      originalHeight: raster.height,
+      resizedWidth,
+      resizedHeight,
+      scale,
+      scaleX,
+      scaleY,
+      padLeft,
+      padTop
+    }
+  };
+}
+
+// src/detection/detector.ts
+function nowDefault2() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function elapsed(clock, startedAt) {
+  return Math.max(0, clock() - startedAt);
+}
+function throwIfAborted2(signal) {
+  if (signal?.aborted) {
+    throw new PPDetectionError("ABORTED", "\u68C0\u6D4B\u5DF2\u53D6\u6D88", { reason: signal.reason });
+  }
+}
+function validateThreshold(value, path) {
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new PPDetectionError("INVALID_INPUT", `${path} \u5FC5\u987B\u662F 0 \u5230 1 \u7684\u6709\u9650\u6570\u503C`, {
+      path,
+      value
+    });
+  }
+}
+function validateDetectOptions(labels, options) {
+  if (options.threshold !== void 0) validateThreshold(options.threshold, "threshold");
+  if (options.classThresholds === void 0) return;
+  for (const [label, value] of Object.entries(options.classThresholds)) {
+    if (!labels.includes(label)) {
+      throw new PPDetectionError("INVALID_INPUT", `classThresholds \u5305\u542B\u672A\u77E5\u7C7B\u522B ${label}`, {
+        label
+      });
+    }
+    validateThreshold(value, `classThresholds.${label}`);
+  }
+}
+var PPDetectionDetectorImplementation = class {
+  constructor(options) {
+    this.options = options;
+    this.capabilities = options.capabilities;
+    this.manifest = options.manifest;
+    this.model = options.model;
+    this.runtime = options.runtime;
+    this.loadTimings = options.loadTimings;
+    this.clock = options.now ?? nowDefault2;
+  }
+  options;
+  capabilities;
+  manifest;
+  model;
+  runtime;
+  loadTimings;
+  clock;
+  executor;
+  loadPromise;
+  disposePromise;
+  queue = Promise.resolve();
+  disposed = false;
+  async load(options = {}) {
+    if (this.disposed) throw new PPDetectionError("DISPOSED", "\u68C0\u6D4B\u5668\u5DF2\u91CA\u653E");
+    throwIfAborted2(options.signal);
+    if (this.executor) return;
+    this.loadPromise ??= this.options.loadExecutor(options.signal).then(async (executor) => {
+      if (this.disposed) {
+        await executor.dispose();
+        throw new PPDetectionError("DISPOSED", "\u68C0\u6D4B\u5668\u5DF2\u91CA\u653E");
+      }
+      this.executor = executor;
+    });
+    try {
+      await this.loadPromise;
+    } catch (error) {
+      this.loadPromise = void 0;
+      throw error;
+    }
+  }
+  detect(input, options = {}) {
+    if (this.disposed) return Promise.reject(new PPDetectionError("DISPOSED", "\u68C0\u6D4B\u5668\u5DF2\u91CA\u653E"));
+    if (!this.executor) {
+      return Promise.reject(new PPDetectionError("SESSION_CREATE_FAILED", "\u68C0\u6D4B\u5668\u5C1A\u672A\u52A0\u8F7D"));
+    }
+    try {
+      validateDetectOptions(this.manifest.labels, options);
+    } catch (error) {
+      return Promise.reject(
+        error instanceof Error ? error : new PPDetectionError("INVALID_INPUT", String(error))
+      );
+    }
+    const operation = this.queue.then(() => this.detectOnce(input, options));
+    this.queue = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    return operation;
+  }
+  getCacheEstimate() {
+    return this.options.getCacheEstimate?.() ?? Promise.resolve({ bytes: 0, entries: 0 });
+  }
+  clearCurrentModelCache() {
+    return this.options.clearCurrentModelCache?.() ?? Promise.resolve();
+  }
+  clearAllCache() {
+    return this.options.clearAllCache?.() ?? Promise.resolve();
+  }
+  clearModelCache() {
+    return this.clearCurrentModelCache();
+  }
+  async dispose() {
+    if (this.disposePromise) return await this.disposePromise;
+    this.disposed = true;
+    this.disposePromise = (async () => {
+      await this.queue;
+      await this.executor?.dispose();
+      this.executor = void 0;
+      await this.options.disposeResources?.();
+    })();
+    await this.disposePromise;
+  }
+  async detectOnce(input, options) {
+    if (this.disposed) throw new PPDetectionError("DISPOSED", "\u68C0\u6D4B\u5668\u5DF2\u91CA\u653E");
+    const executor = this.executor;
+    if (!executor) throw new PPDetectionError("SESSION_CREATE_FAILED", "\u68C0\u6D4B\u5668\u5C1A\u672A\u52A0\u8F7D");
+    throwIfAborted2(options.signal);
+    const totalStartedAt = this.clock();
+    const decoded = await decodeImageSource(input, {
+      ...this.options.decodeEnvironment,
+      signal: options.signal,
+      now: this.clock
+    });
+    throwIfAborted2(options.signal);
+    this.options.onProgress?.({ phase: "preprocess", status: "start" });
+    const preprocessStartedAt = this.clock();
+    const preprocessed = preprocessImage(decoded, this.manifest.preprocessing);
+    const preprocessMs = elapsed(this.clock, preprocessStartedAt);
+    this.options.onProgress?.({ phase: "preprocess", status: "complete" });
+    this.options.onProgress?.({ phase: "inference", status: "start" });
+    const inferenceStartedAt = this.clock();
+    const outputs = await executor.run(
+      {
+        inputName: this.manifest.input.name,
+        data: preprocessed.data,
+        dims: preprocessed.dims
+      },
+      options.signal
+    );
+    const inferenceMs = elapsed(this.clock, inferenceStartedAt);
+    this.options.onProgress?.({ phase: "inference", status: "complete" });
+    throwIfAborted2(options.signal);
+    this.options.onProgress?.({ phase: "postprocess", status: "start" });
+    const postprocessStartedAt = this.clock();
+    const detections = decodeDetectionOutputs(outputs, {
+      labels: this.manifest.labels,
+      scoreThreshold: options.threshold ?? this.manifest.postprocessing.scoreThreshold,
+      classThresholds: options.classThresholds,
+      iouThreshold: this.manifest.postprocessing.iouThreshold,
+      transform: preprocessed.transform,
+      outputs: this.manifest.outputs,
+      matrixCoordinates: this.manifest.postprocessing.matrixCoordinates,
+      queryCoordinates: this.manifest.postprocessing.queryCoordinates,
+      queryBoxFormat: this.manifest.postprocessing.queryBoxFormat
+    });
+    const postprocessMs = elapsed(this.clock, postprocessStartedAt);
+    this.options.onProgress?.({ phase: "postprocess", status: "complete" });
+    return {
+      detections,
+      image: {
+        input: this.manifest.preprocessing.size,
+        original: { width: decoded.width, height: decoded.height }
+      },
+      model: this.model,
+      runtime: this.runtime,
+      timings: {
+        decodeMs: decoded.decodeMs,
+        preprocessMs,
+        inferenceMs,
+        postprocessMs,
+        totalMs: elapsed(this.clock, totalStartedAt)
+      },
+      ...options.timestampMs === void 0 && options.metadata === void 0 ? {} : { frame: { timestampMs: options.timestampMs, metadata: options.metadata } }
+    };
+  }
+};
+
+// src/model/manifest.ts
+var SOURCE_KINDS = /* @__PURE__ */ new Set(["git-lfs", "huggingface", "modelscope", "custom"]);
+var BACKENDS = /* @__PURE__ */ new Set(["wasm", "webgpu"]);
+var PRECISIONS = /* @__PURE__ */ new Set(["fp32", "fp16", "int8", "int4", "fp8"]);
+var REVISION_PATTERN = /^[a-fA-F0-9]{40,64}$/;
+var SHA256_PATTERN = /^[a-fA-F0-9]{64}$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalid(path, message) {
+  throw new PPDetectionError("INVALID_MANIFEST", `\u6A21\u578B\u6E05\u5355 ${path} ${message}`, { path });
+}
+function record(value, path) {
+  if (!isRecord(value)) invalid(path, "\u5FC5\u987B\u662F\u5BF9\u8C61");
+  return value;
+}
+function text(value, path) {
+  if (typeof value !== "string" || value.trim() === "") invalid(path, "\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+  return value;
+}
+function positiveInteger(value, path) {
+  if (!Number.isInteger(value) || value <= 0) invalid(path, "\u5FC5\u987B\u662F\u6B63\u6574\u6570");
+  return value;
+}
+function nonNegativeIntegerOrNull(value, path) {
+  if (value === null) return null;
+  if (!Number.isInteger(value) || value < 0) invalid(path, "\u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570\u6216 null");
+  return value;
+}
+function threshold(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1)
+    invalid(path, "\u5FC5\u987B\u662F 0 \u5230 1 \u7684\u6709\u9650\u6570\u503C");
+  return value;
+}
+function optionalCoordinate(value, path) {
+  if (value === void 0) return void 0;
+  if (value === "pixels") return "pixels";
+  if (value === "normalized") return "normalized";
+  invalid(path, "\u5FC5\u987B\u662F pixels \u6216 normalized");
+}
+function optionalBoxFormat(value, path) {
+  if (value === void 0) return void 0;
+  if (value === "cxcywh") return "cxcywh";
+  if (value === "xyxy") return "xyxy";
+  invalid(path, "\u5FC5\u987B\u662F cxcywh \u6216 xyxy");
+}
+function optionalResizeMode(value, path) {
+  if (value === void 0) return void 0;
+  if (value === "letterbox" || value === "stretch") return value;
+  invalid(path, "\u5FC5\u987B\u662F letterbox \u6216 stretch");
+}
+function optionalInterpolation(value, path) {
+  if (value === void 0) return void 0;
+  if (value === "bilinear" || value === "bicubic") return value;
+  invalid(path, "\u5FC5\u987B\u662F bilinear \u6216 bicubic");
+}
+function optionalFiniteNumbers(value, path) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.length === 0 || !value.every((item) => typeof item === "number" && Number.isFinite(item))) {
+    invalid(path, "\u5FC5\u987B\u662F\u975E\u7A7A\u7684\u6709\u9650\u6570\u503C\u6570\u7EC4");
+  }
+  return value.map((item) => item);
+}
+function tensor(value, path, allowDynamic = false) {
+  const candidate = record(value, path);
+  const shape = candidate.shape;
+  if (!Array.isArray(shape) || shape.length === 0 || !shape.every(
+    (dimension) => Number.isInteger(dimension) && (dimension > 0 || allowDynamic && dimension === -1)
+  )) {
+    invalid(`${path}.shape`, "\u5FC5\u987B\u662F\u975E\u7A7A\u7684\u6B63\u6574\u6570\u6570\u7EC4");
+  }
+  return {
+    name: text(candidate.name, `${path}.name`),
+    shape: shape.map((dimension) => dimension),
+    dtype: text(candidate.dtype, `${path}.dtype`)
+  };
+}
+function source(value, path, variantBytes) {
+  const candidate = record(value, path);
+  if (typeof candidate.kind !== "string" || !SOURCE_KINDS.has(candidate.kind))
+    invalid(`${path}.kind`, "\u4E0D\u53D7\u652F\u6301");
+  const revision = text(candidate.revision, `${path}.revision`);
+  if (!REVISION_PATTERN.test(revision))
+    invalid(`${path}.revision`, "\u5FC5\u987B\u662F 40 \u81F3 64 \u4F4D\u5341\u516D\u8FDB\u5236\u4E0D\u53EF\u53D8 revision");
+  const downloadUrl = text(candidate.downloadUrl, `${path}.downloadUrl`);
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(downloadUrl);
+  } catch {
+    invalid(`${path}.downloadUrl`, "\u5FC5\u987B\u662F\u6709\u6548 URL");
+  }
+  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:" || parsedUrl.hostname === "") {
+    invalid(`${path}.downloadUrl`, "\u5FC5\u987B\u662F\u542B\u4E3B\u673A\u7684 HTTP(S) URL");
+  }
+  const bytes = positiveInteger(candidate.bytes, `${path}.bytes`);
+  if (bytes !== variantBytes) invalid(`${path}.bytes`, "\u5FC5\u987B\u4E0E\u53D8\u4F53\u5927\u5C0F\u4E00\u81F4");
+  const sha256 = text(candidate.sha256, `${path}.sha256`).toLowerCase();
+  if (!SHA256_PATTERN.test(sha256)) invalid(`${path}.sha256`, "\u5FC5\u987B\u662F 64 \u4F4D\u5341\u516D\u8FDB\u5236\u6458\u8981");
+  return {
+    kind: candidate.kind,
+    repository: text(candidate.repository, `${path}.repository`),
+    revision,
+    path: text(candidate.path, `${path}.path`),
+    downloadUrl,
+    bytes,
+    sha256
+  };
+}
+function variant(value, path) {
+  const candidate = record(value, path);
+  if (typeof candidate.precision !== "string" || !PRECISIONS.has(candidate.precision))
+    invalid(`${path}.precision`, "\u4E0D\u53D7\u652F\u6301");
+  if (candidate.quantization !== null && (typeof candidate.quantization !== "string" || candidate.quantization.trim() === "")) {
+    invalid(`${path}.quantization`, "\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u6216 null");
+  }
+  if (!Array.isArray(candidate.backends) || candidate.backends.length === 0 || !candidate.backends.every(
+    (backend) => typeof backend === "string" && BACKENDS.has(backend)
+  )) {
+    invalid(`${path}.backends`, "\u5FC5\u987B\u662F\u975E\u7A7A\u7684 wasm/webgpu \u6570\u7EC4");
+  }
+  const bytes = positiveInteger(candidate.bytes, `${path}.bytes`);
+  if (!Array.isArray(candidate.sources) || candidate.sources.length === 0)
+    invalid(`${path}.sources`, "\u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+  const sources = candidate.sources.map(
+    (item, index) => source(item, `${path}.sources[${index}]`, bytes)
+  );
+  if (new Set(sources.map((item) => item.kind)).size !== sources.length)
+    invalid(`${path}.sources`, "\u540C\u4E00\u53D8\u4F53\u4E2D\u7684\u6765\u6E90 kind \u4E0D\u5F97\u91CD\u590D");
+  const backends = candidate.backends.map((backend) => backend);
+  const status = candidate.status;
+  if (status !== void 0 && status !== "stable" && status !== "labs" && status !== "blocked")
+    invalid(`${path}.status`, "\u4E0D\u53D7\u652F\u6301");
+  return {
+    id: text(candidate.id, `${path}.id`),
+    precision: candidate.precision,
+    quantization: candidate.quantization === null ? null : candidate.quantization,
+    opset: positiveInteger(candidate.opset, `${path}.opset`),
+    bytes,
+    parameterCount: nonNegativeIntegerOrNull(candidate.parameterCount, `${path}.parameterCount`),
+    backends,
+    sources,
+    ...status === void 0 ? {} : { status }
+  };
+}
+function parseDetectionManifest(value) {
+  const candidate = record(value, "\u6839\u8282\u70B9");
+  if (candidate.schemaVersion !== 1) invalid("schemaVersion", "\u5FC5\u987B\u662F 1");
+  const modelValue = record(candidate.model, "model");
+  const model = {
+    id: text(modelValue.id, "model.id"),
+    version: text(modelValue.version, "model.version")
+  };
+  if (!Array.isArray(candidate.outputs) || candidate.outputs.length === 0)
+    invalid("outputs", "\u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+  const preprocessing = record(candidate.preprocessing, "preprocessing");
+  const size = record(preprocessing.size, "preprocessing.size");
+  if (typeof preprocessing.rescaleFactor !== "number" || !Number.isFinite(preprocessing.rescaleFactor) || preprocessing.rescaleFactor <= 0) {
+    invalid("preprocessing.rescaleFactor", "\u5FC5\u987B\u662F\u6B63\u6709\u9650\u6570\u503C");
+  }
+  for (const field of ["doResize", "doRescale", "doNormalize"]) {
+    if (preprocessing[field] !== void 0 && typeof preprocessing[field] !== "boolean")
+      invalid(`preprocessing.${field}`, "\u5FC5\u987B\u662F\u5E03\u5C14\u503C");
+  }
+  const postprocessing = record(candidate.postprocessing, "postprocessing");
+  if (postprocessing.type !== "nms") invalid("postprocessing.type", "\u76EE\u524D\u53EA\u652F\u6301 nms");
+  const matrixCoordinates = optionalCoordinate(
+    postprocessing.matrixCoordinates,
+    "postprocessing.matrixCoordinates"
+  );
+  const queryCoordinates = optionalCoordinate(
+    postprocessing.queryCoordinates,
+    "postprocessing.queryCoordinates"
+  );
+  const queryBoxFormat = optionalBoxFormat(
+    postprocessing.queryBoxFormat,
+    "postprocessing.queryBoxFormat"
+  );
+  const resizeMode2 = optionalResizeMode(preprocessing.resizeMode, "preprocessing.resizeMode");
+  const interpolation2 = optionalInterpolation(
+    preprocessing.interpolation,
+    "preprocessing.interpolation"
+  );
+  if (!Array.isArray(candidate.labels) || candidate.labels.length === 0 || !candidate.labels.every((label) => typeof label === "string" && label.trim() !== "")) {
+    invalid("labels", "\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u6570\u7EC4");
+  }
+  if (!Array.isArray(candidate.variants) || candidate.variants.length === 0)
+    invalid("variants", "\u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+  const variants = candidate.variants.map((item, index) => variant(item, `variants[${index}]`));
+  if (new Set(variants.map((item) => item.id)).size !== variants.length)
+    invalid("variants", "\u53D8\u4F53 id \u4E0D\u5F97\u91CD\u590D");
+  const input = tensor(candidate.input, "input");
+  const mean = optionalFiniteNumbers(preprocessing.mean, "preprocessing.mean");
+  const std = optionalFiniteNumbers(preprocessing.std, "preprocessing.std");
+  const channels = input.shape[1];
+  if (mean !== void 0 && mean.length !== channels)
+    invalid("preprocessing.mean", "\u957F\u5EA6\u5FC5\u987B\u4E0E\u8F93\u5165\u901A\u9053\u6570\u4E00\u81F4");
+  if (std !== void 0 && std.length !== channels)
+    invalid("preprocessing.std", "\u957F\u5EA6\u5FC5\u987B\u4E0E\u8F93\u5165\u901A\u9053\u6570\u4E00\u81F4");
+  if (std?.some((value2) => value2 <= 0)) invalid("preprocessing.std", "\u5FC5\u987B\u5168\u90E8\u5927\u4E8E\u96F6");
+  return {
+    schemaVersion: 1,
+    model,
+    input,
+    outputs: candidate.outputs.map((item, index) => tensor(item, `outputs[${index}]`, true)),
+    preprocessing: {
+      size: {
+        width: positiveInteger(size.width, "preprocessing.size.width"),
+        height: positiveInteger(size.height, "preprocessing.size.height")
+      },
+      rescaleFactor: preprocessing.rescaleFactor,
+      ...resizeMode2 === void 0 ? {} : { resizeMode: resizeMode2 },
+      ...interpolation2 === void 0 ? {} : { interpolation: interpolation2 },
+      ...typeof preprocessing.doResize === "boolean" ? { doResize: preprocessing.doResize } : {},
+      ...typeof preprocessing.doRescale === "boolean" ? { doRescale: preprocessing.doRescale } : {},
+      ...typeof preprocessing.doNormalize === "boolean" ? { doNormalize: preprocessing.doNormalize } : {},
+      ...mean === void 0 ? {} : { mean },
+      ...std === void 0 ? {} : { std }
+    },
+    postprocessing: {
+      type: "nms",
+      scoreThreshold: threshold(postprocessing.scoreThreshold, "postprocessing.scoreThreshold"),
+      iouThreshold: threshold(postprocessing.iouThreshold, "postprocessing.iouThreshold"),
+      ...matrixCoordinates === void 0 ? {} : { matrixCoordinates },
+      ...queryCoordinates === void 0 ? {} : { queryCoordinates },
+      ...queryBoxFormat === void 0 ? {} : { queryBoxFormat }
+    },
+    labels: candidate.labels.map((label) => label),
+    variants
+  };
+}
+
+// src/model/public-manifest.ts
+var SHA256_PATTERN2 = /^[a-fA-F0-9]{64}$/;
+var BACKENDS2 = /* @__PURE__ */ new Set(["wasm", "webgpu"]);
+var PRECISIONS2 = /* @__PURE__ */ new Set(["fp32", "fp16", "int8", "int4", "fp8"]);
+function record2(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new PPDetectionError("INVALID_MANIFEST", `\u6A21\u578B\u6E05\u5355 ${path} \u5FC5\u987B\u662F\u5BF9\u8C61`, { path });
+  }
+  return value;
+}
+function invalid2(path, message) {
+  throw new PPDetectionError("INVALID_MANIFEST", `\u6A21\u578B\u6E05\u5355 ${path} ${message}`, { path });
+}
+function text2(value, path) {
+  if (typeof value !== "string" || value.trim() === "") invalid2(path, "\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+  return value;
+}
+function integer(value, path, allowZero = false) {
+  if (!Number.isInteger(value) || (allowZero ? value < 0 : value <= 0)) {
+    invalid2(path, allowZero ? "\u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570" : "\u5FC5\u987B\u662F\u6B63\u6574\u6570");
+  }
+  return value;
+}
+function nonNegativeIntegerOrNull2(value, path) {
+  if (value === null) return null;
+  return integer(value, path, true);
+}
+function finite(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value)) invalid2(path, "\u5FC5\u987B\u662F\u6709\u9650\u6570\u503C");
+  return value;
+}
+function boolean(value, path) {
+  if (typeof value !== "boolean") invalid2(path, "\u5FC5\u987B\u662F\u5E03\u5C14\u503C");
+  return value;
+}
+function resizeMode(value, path) {
+  if (value === void 0) return void 0;
+  if (value === "letterbox" || value === "stretch") return value;
+  invalid2(path, "\u5FC5\u987B\u662F letterbox \u6216 stretch");
+}
+function interpolation(value, path) {
+  if (value === void 0) return void 0;
+  if (value === "bilinear" || value === "bicubic") return value;
+  invalid2(path, "\u5FC5\u987B\u662F bilinear \u6216 bicubic");
+}
+function resample(value, path) {
+  const result = integer(value, path, true);
+  if (result === 2 || result === 3) return result;
+  invalid2(path, "\u76EE\u524D\u53EA\u652F\u6301 2 (bilinear) \u6216 3 (bicubic)");
+}
+function url(value, path) {
+  const result = text2(value, path);
+  try {
+    const parsed = new URL(result);
+    if (!["http:", "https:"].includes(parsed.protocol) || !parsed.hostname) throw new Error();
+  } catch {
+    invalid2(path, "\u5FC5\u987B\u662F\u542B\u4E3B\u673A\u7684 HTTP(S) URL");
+  }
+  return result;
+}
+function tensor2(value, path, allowDynamic = false) {
+  const candidate = record2(value, path);
+  if (!Array.isArray(candidate.shape) || candidate.shape.length === 0 || !candidate.shape.every(
+    (dimension) => Number.isInteger(dimension) && (dimension > 0 || allowDynamic && dimension === -1)
+  )) {
+    invalid2(`${path}.shape`, "\u5FC5\u987B\u662F\u6B63\u6574\u6570\u6570\u7EC4");
+  }
+  return {
+    name: text2(candidate.name, `${path}.name`),
+    dtype: text2(candidate.dtype, `${path}.dtype`),
+    shape: candidate.shape.map(Number)
+  };
+}
+function triple(value, path, positive = false) {
+  if (!Array.isArray(value) || value.length !== 3) invalid2(path, "\u5FC5\u987B\u5305\u542B 3 \u4E2A\u6570\u503C");
+  const result = value.map((item, index) => finite(item, `${path}[${index}]`));
+  if (positive && result.some((item) => item <= 0)) invalid2(path, "\u5FC5\u987B\u5168\u90E8\u5927\u4E8E\u96F6");
+  return result;
+}
+function variant2(value, path) {
+  const candidate = record2(value, path);
+  if (!Array.isArray(candidate.backendCompatibility) || candidate.backendCompatibility.length === 0 || !candidate.backendCompatibility.every(
+    (backend) => typeof backend === "string" && BACKENDS2.has(backend)
+  )) {
+    invalid2(`${path}.backendCompatibility`, "\u5FC5\u987B\u662F\u975E\u7A7A\u7684 wasm/webgpu \u6570\u7EC4");
+  }
+  if (typeof candidate.precision !== "string" || !PRECISIONS2.has(candidate.precision)) {
+    invalid2(`${path}.precision`, "\u4E0D\u53D7\u652F\u6301");
+  }
+  if (candidate.quantization !== void 0 && candidate.quantization !== null && (typeof candidate.quantization !== "string" || candidate.quantization.trim() === "")) {
+    invalid2(`${path}.quantization`, "\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u6216 null");
+  }
+  const sha256 = text2(candidate.sha256, `${path}.sha256`).toLowerCase();
+  if (!SHA256_PATTERN2.test(sha256)) invalid2(`${path}.sha256`, "\u5FC5\u987B\u662F 64 \u4F4D\u5341\u516D\u8FDB\u5236\u6458\u8981");
+  const validation = record2(candidate.validation, `${path}.validation`);
+  return {
+    backendCompatibility: candidate.backendCompatibility.map((backend) => backend),
+    bytes: integer(candidate.bytes, `${path}.bytes`),
+    filename: text2(candidate.filename, `${path}.filename`),
+    id: text2(candidate.id, `${path}.id`),
+    opset: integer(candidate.opset, `${path}.opset`),
+    precision: candidate.precision,
+    quantization: candidate.quantization === void 0 ? null : candidate.quantization,
+    sha256,
+    url: url(candidate.url, `${path}.url`),
+    validation: {
+      included: boolean(validation.included, `${path}.validation.included`),
+      pass: boolean(validation.pass, `${path}.validation.pass`),
+      report: text2(validation.report, `${path}.validation.report`)
+    }
+  };
+}
+function parseModelManifest(value) {
+  const candidate = record2(value, "\u6839\u8282\u70B9");
+  if (candidate.schemaVersion !== 1) invalid2("schemaVersion", "\u5FC5\u987B\u662F 1");
+  const model = record2(candidate.model, "model");
+  const preprocessing = record2(candidate.preprocessing, "preprocessing");
+  const size = record2(preprocessing.size, "preprocessing.size");
+  const source2 = record2(candidate.source, "source");
+  const files = record2(source2.files, "source.files");
+  const preprocessingInterpolation = interpolation(
+    preprocessing.interpolation,
+    "preprocessing.interpolation"
+  );
+  const preprocessingResample = resample(preprocessing.resample, "preprocessing.resample");
+  const input = tensor2(candidate.input, "input");
+  if (input.shape.length !== 4 || input.shape[0] !== 1 || input.shape[1] !== 3) {
+    invalid2("input.shape", "\u76EE\u524D\u53EA\u652F\u6301 [1,3,H,W]");
+  }
+  if (!Array.isArray(candidate.outputs) || candidate.outputs.length === 0) {
+    invalid2("outputs", "\u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+  }
+  if (!Array.isArray(candidate.labels) || !candidate.labels.length)
+    invalid2("labels", "\u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+  const labels = candidate.labels.map((label, index) => text2(label, `labels[${index}]`));
+  if (!Array.isArray(candidate.variants) || !candidate.variants.length) {
+    invalid2("variants", "\u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+  }
+  const variants = candidate.variants.map((item, index) => variant2(item, `variants[${index}]`));
+  if (new Set(variants.map((item) => item.id)).size !== variants.length)
+    invalid2("variants", "id \u4E0D\u5F97\u91CD\u590D");
+  if (!Array.isArray(candidate.variantPriority) || !candidate.variantPriority.length) {
+    invalid2("variantPriority", "\u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+  }
+  const variantPriority = candidate.variantPriority.map(
+    (item, index) => text2(item, `variantPriority[${index}]`)
+  );
+  if (variantPriority.some((id) => !variants.some((item) => item.id === id))) {
+    invalid2("variantPriority", "\u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684\u53D8\u4F53");
+  }
+  const normalizedFiles = Object.fromEntries(
+    Object.entries(files).map(([name, hash]) => {
+      const normalized = text2(hash, `source.files.${name}`).toLowerCase();
+      if (!SHA256_PATTERN2.test(normalized)) invalid2(`source.files.${name}`, "\u5FC5\u987B\u662F SHA-256");
+      return [name, normalized];
+    })
+  );
+  return {
+    schemaVersion: 1,
+    minSdkVersion: text2(candidate.minSdkVersion, "minSdkVersion"),
+    model: {
+      architecture: text2(model.architecture, "model.architecture"),
+      id: text2(model.id, "model.id"),
+      modelType: text2(model.modelType, "model.modelType"),
+      parameterCount: nonNegativeIntegerOrNull2(model.parameterCount, "model.parameterCount"),
+      version: text2(model.version, "model.version")
+    },
+    input,
+    outputs: candidate.outputs.map((item, index) => tensor2(item, `outputs[${index}]`, true)),
+    preprocessing: {
+      doNormalize: boolean(preprocessing.doNormalize, "preprocessing.doNormalize"),
+      doRescale: boolean(preprocessing.doRescale, "preprocessing.doRescale"),
+      doResize: boolean(preprocessing.doResize, "preprocessing.doResize"),
+      ...resizeMode(preprocessing.resizeMode, "preprocessing.resizeMode") === void 0 ? {} : { resizeMode: resizeMode(preprocessing.resizeMode, "preprocessing.resizeMode") },
+      ...preprocessingInterpolation === void 0 ? {} : { interpolation: preprocessingInterpolation },
+      imageMean: triple(preprocessing.imageMean, "preprocessing.imageMean"),
+      imageStd: triple(preprocessing.imageStd, "preprocessing.imageStd", true),
+      resample: preprocessingResample,
+      rescaleFactor: finite(preprocessing.rescaleFactor, "preprocessing.rescaleFactor"),
+      size: {
+        height: integer(size.height, "preprocessing.size.height"),
+        width: integer(size.width, "preprocessing.size.width")
+      }
+    },
+    source: {
+      files: normalizedFiles,
+      license: text2(source2.license, "source.license"),
+      name: text2(source2.name, "source.name"),
+      url: url(source2.url, "source.url")
+    },
+    labels,
+    variantPriority,
+    variants
+  };
+}
+function sourceKind(downloadUrl) {
+  const hostname = new URL(downloadUrl).hostname.toLowerCase();
+  if (hostname.includes("huggingface.co")) return "huggingface";
+  if (hostname.includes("modelscope")) return "modelscope";
+  return "custom";
+}
+function adaptModelManifest(manifest) {
+  const preprocessingResample = resample(manifest.preprocessing.resample, "preprocessing.resample");
+  const priority = new Map(manifest.variantPriority.map((id, index) => [id, index]));
+  const variants = [...manifest.variants].sort(
+    (left, right) => (priority.get(left.id) ?? manifest.variantPriority.length + manifest.variants.indexOf(left)) - (priority.get(right.id) ?? manifest.variantPriority.length + manifest.variants.indexOf(right))
+  );
+  return parseDetectionManifest({
+    schemaVersion: 1,
+    model: { id: manifest.model.id, version: manifest.model.version },
+    input: manifest.input,
+    outputs: manifest.outputs,
+    preprocessing: {
+      size: manifest.preprocessing.size,
+      rescaleFactor: manifest.preprocessing.rescaleFactor,
+      doResize: manifest.preprocessing.doResize,
+      resizeMode: manifest.preprocessing.resizeMode,
+      interpolation: manifest.preprocessing.interpolation ?? (preprocessingResample === 3 ? "bicubic" : "bilinear"),
+      doRescale: manifest.preprocessing.doRescale,
+      doNormalize: manifest.preprocessing.doNormalize,
+      mean: manifest.preprocessing.imageMean,
+      std: manifest.preprocessing.imageStd
+    },
+    postprocessing: { type: "nms", scoreThreshold: 0.5, iouThreshold: 0.5 },
+    labels: manifest.labels,
+    variants: variants.map((variant3) => ({
+      id: variant3.id,
+      precision: variant3.precision,
+      quantization: variant3.quantization ?? null,
+      opset: variant3.opset,
+      bytes: variant3.bytes,
+      parameterCount: manifest.model.parameterCount,
+      backends: variant3.backendCompatibility,
+      status: variant3.validation.included && variant3.validation.pass ? "stable" : "blocked",
+      sources: [
+        {
+          kind: sourceKind(variant3.url),
+          repository: manifest.source.url,
+          revision: variant3.sha256,
+          path: variant3.filename,
+          downloadUrl: variant3.url,
+          bytes: variant3.bytes,
+          sha256: variant3.sha256
+        }
+      ]
+    }))
+  });
+}
+
+// src/cache/indexeddb-cache.ts
+var IndexedDBModelCache = class {
+  factory;
+  databaseName;
+  database;
+  constructor(options = {}) {
+    const factory = options.indexedDB ?? globalThis.indexedDB;
+    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";
+  }
+  async get(key) {
+    const record3 = await this.request(
+      "readonly",
+      (store) => store.get(key)
+    );
+    return record3?.bytes.slice(0);
+  }
+  async put(key, bytes) {
+    const stored = bytes.slice(0);
+    await this.request(
+      "readwrite",
+      (store) => store.put({ key, bytes: stored, size: stored.byteLength })
+    );
+  }
+  async clearCurrent(key) {
+    await this.request("readwrite", (store) => store.delete(key));
+  }
+  async clearAll() {
+    await this.request("readwrite", (store) => store.clear());
+  }
+  async estimate() {
+    const database = await this.open();
+    return await new Promise((resolve, reject) => {
+      const transaction = database.transaction("models", "readonly");
+      const request = transaction.objectStore("models").openCursor();
+      let bytes = 0;
+      let entries = 0;
+      let cursorFinished = false;
+      request.onerror = () => reject(request.error ?? new Error("\u8BFB\u53D6 IndexedDB \u7F13\u5B58\u5931\u8D25"));
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor) {
+          cursorFinished = true;
+          return;
+        }
+        const value = cursor.value;
+        bytes += typeof value.size === "number" ? value.size : value.bytes.byteLength;
+        entries += 1;
+        cursor.continue();
+      };
+      transaction.oncomplete = () => {
+        if (cursorFinished) resolve({ bytes, entries });
+        else reject(new Error("IndexedDB \u7F13\u5B58\u6E38\u6807\u672A\u5B8C\u6210"));
+      };
+      transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB \u7F13\u5B58\u4E8B\u52A1\u4E2D\u6B62"));
+    });
+  }
+  async close() {
+    if (!this.database) return;
+    (await this.database).close();
+    this.database = void 0;
+  }
+  open() {
+    if (this.database) return this.database;
+    this.database = new Promise((resolve, reject) => {
+      const request = this.factory.open(this.databaseName, 1);
+      request.onupgradeneeded = () => {
+        if (!request.result.objectStoreNames.contains("models"))
+          request.result.createObjectStore("models", { keyPath: "key" });
+      };
+      request.onerror = () => reject(request.error ?? new Error("\u6253\u5F00 IndexedDB \u7F13\u5B58\u5931\u8D25"));
+      request.onsuccess = () => resolve(request.result);
+      request.onblocked = () => reject(new Error("IndexedDB \u7F13\u5B58\u5347\u7EA7\u88AB\u963B\u585E"));
+    });
+    this.database.catch(() => {
+      this.database = void 0;
+    });
+    return this.database;
+  }
+  async request(mode, operation) {
+    const database = await this.open();
+    return await new Promise((resolve, reject) => {
+      const transaction = database.transaction("models", mode);
+      const request = operation(transaction.objectStore("models"));
+      let requestFinished = false;
+      let result;
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB \u7F13\u5B58\u64CD\u4F5C\u5931\u8D25"));
+      request.onsuccess = () => {
+        requestFinished = true;
+        result = request.result;
+      };
+      transaction.oncomplete = () => {
+        if (requestFinished) resolve(result);
+        else reject(new Error("IndexedDB \u7F13\u5B58\u8BF7\u6C42\u672A\u5B8C\u6210"));
+      };
+      transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB \u7F13\u5B58\u4E8B\u52A1\u4E2D\u6B62"));
+    });
+  }
+};
+
+// src/cache/memory-cache.ts
+function clone(bytes) {
+  return bytes.slice(0);
+}
+var MemoryModelCache = class {
+  entries = /* @__PURE__ */ new Map();
+  get(key) {
+    const value = this.entries.get(key);
+    return Promise.resolve(value ? clone(value) : void 0);
+  }
+  put(key, bytes) {
+    this.entries.set(key, clone(bytes));
+    return Promise.resolve();
+  }
+  clearCurrent(key) {
+    this.entries.delete(key);
+    return Promise.resolve();
+  }
+  clearAll() {
+    this.entries.clear();
+    return Promise.resolve();
+  }
+  estimate() {
+    let bytes = 0;
+    for (const value of this.entries.values()) bytes += value.byteLength;
+    return Promise.resolve({ bytes, entries: this.entries.size });
+  }
+  close() {
+    this.entries.clear();
+    return Promise.resolve();
+  }
+};
+
+// src/cache/model-cache.ts
+var TieredModelCache = class {
+  constructor(memory, persistent) {
+    this.memory = memory;
+    this.persistent = persistent;
+  }
+  memory;
+  persistent;
+  async get(key) {
+    const memoryValue = await this.memory.get(key);
+    if (memoryValue) return memoryValue;
+    const persistentValue = await this.persistent?.get(key);
+    if (persistentValue) await this.memory.put(key, persistentValue);
+    return persistentValue;
+  }
+  async put(key, bytes) {
+    await this.memory.put(key, bytes);
+    await this.persistent?.put(key, bytes);
+  }
+  async clearCurrent(key) {
+    await this.memory.clearCurrent(key);
+    await this.persistent?.clearCurrent(key);
+  }
+  async clearAll() {
+    await this.memory.clearAll();
+    await this.persistent?.clearAll();
+  }
+  estimate() {
+    return this.persistent?.estimate() ?? this.memory.estimate();
+  }
+  async close() {
+    await this.memory.close?.();
+    await this.persistent?.close?.();
+  }
+};
+
+// src/model/integrity.ts
+function abortIfNeeded(signal) {
+  if (signal?.aborted) throw new PPDetectionError("ABORTED", "\u6A21\u578B\u5B8C\u6574\u6027\u6821\u9A8C\u5DF2\u53D6\u6D88");
+}
+async function calculateSha256(bytes, signal) {
+  abortIfNeeded(signal);
+  if (!globalThis.crypto?.subtle) {
+    throw new PPDetectionError("MODEL_INTEGRITY_FAILED", "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 SHA-256 \u5B8C\u6574\u6027\u6821\u9A8C", {
+      algorithm: "SHA-256"
+    });
+  }
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  abortIfNeeded(signal);
+  return Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+async function verifyModelIntegrity(bytes, expected, signal) {
+  abortIfNeeded(signal);
+  if (bytes.byteLength !== expected.bytes) {
+    throw new PPDetectionError("MODEL_INTEGRITY_FAILED", "\u6A21\u578B\u6587\u4EF6\u5927\u5C0F\u4E0E\u6E05\u5355\u4E0D\u4E00\u81F4", {
+      expectedBytes: expected.bytes,
+      actualBytes: bytes.byteLength
+    });
+  }
+  const actualSha256 = await calculateSha256(bytes, signal);
+  if (actualSha256 !== expected.sha256.toLowerCase()) {
+    throw new PPDetectionError("MODEL_INTEGRITY_FAILED", "\u6A21\u578B SHA-256 \u4E0E\u6E05\u5355\u4E0D\u4E00\u81F4", {
+      expectedSha256: expected.sha256.toLowerCase(),
+      actualSha256
+    });
+  }
+}
+
+// src/model/download.ts
+function now() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function aborted(error, signal) {
+  return signal?.aborted === true || error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+function throwIfAborted3(signal) {
+  if (signal?.aborted) throw new PPDetectionError("ABORTED", "\u6A21\u578B\u4E0B\u8F7D\u5DF2\u53D6\u6D88");
+}
+function contentLength(response, expectedBytes) {
+  const raw = response.headers.get("content-length");
+  if (raw === null) return expectedBytes;
+  const actual = Number(raw);
+  if (!Number.isSafeInteger(actual) || actual < 0 || actual !== expectedBytes) {
+    throw new PPDetectionError("MODEL_INTEGRITY_FAILED", "\u54CD\u5E94 Content-Length \u4E0E\u6E05\u5355\u4E0D\u4E00\u81F4", {
+      contentLength: raw,
+      expectedBytes
+    });
+  }
+  return actual;
+}
+function validatePartialResponse(response, expectedBytes) {
+  if (response.status !== 206) return;
+  const raw = response.headers.get("content-range");
+  const match = raw?.match(/^bytes (\d+)-(\d+)\/(\d+)$/i);
+  if (!match || Number(match[1]) !== 0 || Number(match[2]) !== expectedBytes - 1 || Number(match[3]) !== expectedBytes) {
+    throw new PPDetectionError("MODEL_DOWNLOAD_FAILED", "206 \u54CD\u5E94\u672A\u8986\u76D6\u5B8C\u6574\u6A21\u578B\u8303\u56F4", {
+      contentRange: raw,
+      expectedContentRange: `bytes 0-${expectedBytes - 1}/${expectedBytes}`
+    });
+  }
+}
+async function readResponse(response, expectedBytes, signal, onProgress) {
+  const totalBytes = contentLength(response, expectedBytes);
+  if (!response.body) {
+    const bytes2 = await response.arrayBuffer();
+    throwIfAborted3(signal);
+    onProgress?.({ loadedBytes: bytes2.byteLength, totalBytes });
+    return bytes2;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let loadedBytes = 0;
+  try {
+    while (true) {
+      throwIfAborted3(signal);
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      loadedBytes += chunk.value.byteLength;
+      if (loadedBytes > expectedBytes) {
+        throw new PPDetectionError("MODEL_INTEGRITY_FAILED", "\u6A21\u578B\u54CD\u5E94\u8D85\u8FC7\u6E05\u5355\u58F0\u660E\u5927\u5C0F", {
+          expectedBytes,
+          loadedBytes
+        });
+      }
+      chunks.push(chunk.value);
+      onProgress?.({ loadedBytes, totalBytes });
+    }
+  } catch (error) {
+    try {
+      await reader.cancel(error);
+    } catch {
+    }
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(loadedBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  onProgress?.({ loadedBytes, totalBytes });
+  return bytes.buffer;
+}
+async function loadModelAsset(asset, options = {}) {
+  throwIfAborted3(options.signal);
+  const fetcher = options.fetcher ?? globalThis.fetch?.bind(globalThis);
+  if (!fetcher)
+    throw new PPDetectionError("MODEL_DOWNLOAD_FAILED", "\u5F53\u524D\u73AF\u5883\u6CA1\u6709 fetch API", {
+      sourceKind: asset.source.kind
+    });
+  const downloadStarted = now();
+  let response;
+  try {
+    response = await fetcher(asset.source.downloadUrl, { signal: options.signal });
+  } catch (error) {
+    if (aborted(error, options.signal))
+      throw new PPDetectionError("ABORTED", "\u6A21\u578B\u4E0B\u8F7D\u5DF2\u53D6\u6D88", {}, { cause: error });
+    throw new PPDetectionError(
+      "MODEL_DOWNLOAD_FAILED",
+      "\u6A21\u578B\u4E0B\u8F7D\u8BF7\u6C42\u5931\u8D25",
+      {
+        sourceKind: asset.source.kind,
+        downloadUrl: asset.source.downloadUrl
+      },
+      { cause: error }
+    );
+  }
+  if (!response.ok) {
+    throw new PPDetectionError("MODEL_DOWNLOAD_FAILED", "\u6A21\u578B\u4E0B\u8F7D\u8FD4\u56DE\u975E\u6210\u529F\u72B6\u6001", {
+      sourceKind: asset.source.kind,
+      status: response.status,
+      statusText: response.statusText
+    });
+  }
+  validatePartialResponse(response, asset.source.bytes);
+  let bytes;
+  try {
+    bytes = await readResponse(response, asset.source.bytes, options.signal, options.onProgress);
+  } catch (error) {
+    if (error instanceof PPDetectionError) throw error;
+    if (aborted(error, options.signal))
+      throw new PPDetectionError("ABORTED", "\u6A21\u578B\u4E0B\u8F7D\u5DF2\u53D6\u6D88", {}, { cause: error });
+    throw new PPDetectionError(
+      "MODEL_DOWNLOAD_FAILED",
+      "\u8BFB\u53D6\u6A21\u578B\u54CD\u5E94\u5931\u8D25",
+      { sourceKind: asset.source.kind },
+      { cause: error }
+    );
+  }
+  const modelDownloadMs = now() - downloadStarted;
+  const integrityStarted = now();
+  await verifyModelIntegrity(bytes, asset.source, options.signal);
+  return {
+    bytes,
+    timings: {
+      modelDownloadMs,
+      integrityMs: now() - integrityStarted
+    }
+  };
+}
+
+// src/model/source-resolver.ts
+function resolveModelVariant(manifest, variantId) {
+  const variant3 = variantId === void 0 ? manifest.variants[0] : manifest.variants.find((candidate) => candidate.id === variantId);
+  if (!variant3) {
+    throw new PPDetectionError("MODEL_INCOMPATIBLE", "\u8BF7\u6C42\u7684\u6A21\u578B\u53D8\u4F53\u4E0D\u5B58\u5728", {
+      variantId,
+      availableVariants: manifest.variants.map((candidate) => candidate.id)
+    });
+  }
+  return variant3;
+}
+function resolveModelSources(variant3, sourceKind2 = "auto") {
+  if (sourceKind2 === "auto") return variant3.sources;
+  const source2 = variant3.sources.find((candidate) => candidate.kind === sourceKind2);
+  if (!source2) {
+    throw new PPDetectionError("MODEL_SOURCE_UNAVAILABLE", "\u8BF7\u6C42\u7684\u6A21\u578B\u6765\u6E90\u4E0D\u5B58\u5728", {
+      sourceKind: sourceKind2,
+      availableSources: variant3.sources.map((candidate) => candidate.kind)
+    });
+  }
+  return [source2];
+}
+function resolveModelAsset(selection, manifest) {
+  const variant3 = resolveModelVariant(manifest, selection.variantId);
+  const [source2] = resolveModelSources(variant3, selection.sourceKind);
+  if (!source2)
+    throw new PPDetectionError("MODEL_SOURCE_UNAVAILABLE", "\u6A21\u578B\u53D8\u4F53\u6CA1\u6709\u53EF\u7528\u6765\u6E90", {
+      variantId: variant3.id
+    });
+  return { model: manifest.model, variant: variant3, source: source2 };
+}
+
+// src/model/model-manager.ts
+var SDK_CACHE_NAMESPACE = "web-sdk-pp-detection:cache-v1";
+function now2() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function createCache(selection) {
+  if (selection && typeof selection === "object") return selection;
+  const memory = new MemoryModelCache();
+  if (selection === false || selection === "memory" || typeof globalThis.indexedDB === "undefined")
+    return memory;
+  return new TieredModelCache(memory, new IndexedDBModelCache());
+}
+function sourceFailure(source2, error) {
+  return {
+    kind: source2.kind,
+    code: error instanceof PPDetectionError ? error.code : "MODEL_DOWNLOAD_FAILED",
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+function throwIfAborted4(signal) {
+  if (signal?.aborted) throw new PPDetectionError("ABORTED", "\u6A21\u578B\u52A0\u8F7D\u5DF2\u53D6\u6D88");
+}
+var ModelManager = class {
+  fetcher;
+  cache;
+  lifecycle = new AbortController();
+  activeLoads = /* @__PURE__ */ new Set();
+  currentKey;
+  disposed = false;
+  disposePromise;
+  constructor(options = {}) {
+    this.fetcher = options.fetcher;
+    this.cache = createCache(options.cache);
+  }
+  cacheKey(variant3, source2, model = { id: "unknown", version: "unknown" }) {
+    return JSON.stringify([
+      SDK_CACHE_NAMESPACE,
+      model.id,
+      model.version,
+      variant3.id,
+      source2.revision.toLowerCase(),
+      source2.sha256.toLowerCase()
+    ]);
+  }
+  async load(options) {
+    if (this.disposed) throw new PPDetectionError("DISPOSED", "\u6A21\u578B\u7BA1\u7406\u5668\u5DF2\u91CA\u653E");
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    options.signal?.addEventListener("abort", abort, { once: true });
+    this.lifecycle.signal.addEventListener("abort", abort, { once: true });
+    if (options.signal?.aborted || this.lifecycle.signal.aborted) abort();
+    const operation = this.loadActive({ ...options, signal: controller.signal });
+    const tracked = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    this.activeLoads.add(tracked);
+    try {
+      return await operation;
+    } finally {
+      options.signal?.removeEventListener("abort", abort);
+      this.lifecycle.signal.removeEventListener("abort", abort);
+      this.activeLoads.delete(tracked);
+    }
+  }
+  async loadActive(options) {
+    throwIfAborted4(options.signal);
+    const manifest = parseDetectionManifest(options.manifest);
+    const variant3 = resolveModelVariant(manifest, options.variantId);
+    const sourceKind2 = options.sourceKind ?? "auto";
+    const sources = resolveModelSources(variant3, sourceKind2);
+    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);
+      const cacheStarted = now2();
+      let cached;
+      try {
+        cached = await this.cache.get(cacheKey);
+      } catch (error) {
+        if (error instanceof PPDetectionError && error.code === "ABORTED") throw error;
+        throwIfAborted4(options.signal);
+      }
+      throwIfAborted4(options.signal);
+      const modelCacheReadMs = now2() - cacheStarted;
+      if (cached) {
+        const integrityStarted = now2();
+        try {
+          await verifyModelIntegrity(cached, source2, options.signal);
+          this.currentKey = cacheKey;
+          return {
+            bytes: cached,
+            manifest,
+            variant: variant3,
+            source: source2,
+            cacheKey,
+            fromCache: true,
+            failures,
+            timings: { modelCacheReadMs, integrityMs: now2() - integrityStarted }
+          };
+        } catch (error) {
+          if (error instanceof PPDetectionError && error.code === "ABORTED") throw error;
+          try {
+            await this.cache.clearCurrent(cacheKey);
+          } catch (clearError) {
+            if (clearError instanceof PPDetectionError && clearError.code === "ABORTED")
+              throw clearError;
+            throwIfAborted4(options.signal);
+          }
+        }
+      }
+      let loaded;
+      try {
+        loaded = await loadModelAsset(asset, {
+          fetcher: this.fetcher,
+          signal: options.signal,
+          onProgress: options.onProgress
+        });
+      } catch (error) {
+        if (error instanceof PPDetectionError && error.code === "ABORTED") throw error;
+        lastError = error;
+        failures.push(sourceFailure(source2, error));
+        if (sourceKind2 !== "auto") {
+          if (error instanceof PPDetectionError && error.code === "MODEL_INTEGRITY_FAILED")
+            throw error;
+          throw new PPDetectionError(
+            "MODEL_SOURCE_UNAVAILABLE",
+            "\u8BF7\u6C42\u7684\u6A21\u578B\u6765\u6E90\u4E0D\u53EF\u7528",
+            {
+              sourceKind: source2.kind,
+              failures
+            },
+            { cause: error }
+          );
+        }
+        continue;
+      }
+      throwIfAborted4(options.signal);
+      try {
+        await this.cache.put(cacheKey, loaded.bytes);
+      } catch {
+      }
+      throwIfAborted4(options.signal);
+      this.currentKey = cacheKey;
+      return {
+        bytes: loaded.bytes,
+        manifest,
+        variant: variant3,
+        source: source2,
+        cacheKey,
+        fromCache: false,
+        failures,
+        timings: { modelCacheReadMs, ...loaded.timings }
+      };
+    }
+    throw new PPDetectionError(
+      "MODEL_SOURCE_UNAVAILABLE",
+      "\u6240\u6709\u6A21\u578B\u6765\u6E90\u5747\u4E0D\u53EF\u7528",
+      {
+        variantId: variant3.id,
+        failures
+      },
+      { cause: lastError }
+    );
+  }
+  estimate() {
+    return this.getCacheEstimate();
+  }
+  getCacheEstimate() {
+    return this.cache.estimate();
+  }
+  async clearCurrentModelCache() {
+    if (!this.currentKey) return;
+    await this.cache.clearCurrent(this.currentKey);
+  }
+  async clearAllCache() {
+    await this.cache.clearAll();
+    this.currentKey = void 0;
+  }
+  async dispose() {
+    if (this.disposePromise) return await this.disposePromise;
+    this.disposed = true;
+    this.lifecycle.abort();
+    this.disposePromise = (async () => {
+      await Promise.all([...this.activeLoads]);
+      this.currentKey = void 0;
+      await this.cache.close?.();
+    })();
+    await this.disposePromise;
+  }
+};
+
+// src/runtime/ort-session.ts
+function now3() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+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 });
+  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(
+    phase === "create" ? "SESSION_CREATE_FAILED" : "INFERENCE_FAILED",
+    phase === "create" ? "\u521B\u5EFA ONNX Runtime \u4F1A\u8BDD\u5931\u8D25" : "ONNX Runtime \u63A8\u7406\u5931\u8D25",
+    { phase },
+    { cause: error }
+  );
+}
+function normalizeFeeds(feeds, ort) {
+  const Tensor = ort.Tensor;
+  if (!Tensor) return feeds;
+  return Object.fromEntries(
+    Object.entries(feeds).map(([name, value]) => {
+      if (typeof value === "object" && value !== null && "data" in value && "dims" in value && value.data instanceof Float32Array) {
+        const input = value;
+        return [name, new Tensor("float32", input.data, input.dims)];
+      }
+      return [name, value];
+    })
+  );
+}
+async function loadOrt(backend) {
+  return await (backend === "webgpu" ? import('onnxruntime-web/webgpu') : import('onnxruntime-web'));
+}
+async function createOrtSession(modelBytes, plan, options = {}) {
+  try {
+    const ort = options.ort ?? await (options.loadOrt ?? loadOrt)(plan.actualBackend);
+    if (options.wasmPaths && ort.env.wasm) ort.env.wasm.wasmPaths = options.wasmPaths;
+    if (plan.actualBackend === "wasm" && ort.env.wasm && options.numThreads)
+      ort.env.wasm.numThreads = options.numThreads;
+    const sessionStarted = now3();
+    const session = await ort.InferenceSession.create(modelBytes, {
+      ...options.sessionOptions,
+      executionProviders: [plan.actualBackend]
+    });
+    const sessionMs = now3() - sessionStarted;
+    let disposed = false;
+    let disposePromise;
+    const activeRuns = /* @__PURE__ */ new Set();
+    return {
+      plan,
+      sessionMs,
+      async run(feeds, runOptions = {}) {
+        if (disposed) throw new PPDetectionError("DISPOSED", "\u4F1A\u8BDD\u5DF2\u91CA\u653E", { phase: "run" });
+        if (runOptions.signal?.aborted)
+          throw new PPDetectionError("ABORTED", "\u63A8\u7406\u5DF2\u53D6\u6D88", { phase: "run" });
+        const ortRunOptions = {};
+        if (plan.actualBackend === "wasm") ortRunOptions.terminate = false;
+        let cancelled = false;
+        const onAbort = () => {
+          cancelled = true;
+        };
+        runOptions.signal?.addEventListener("abort", onAbort, { once: true });
+        const operation = (async () => {
+          try {
+            const result = await Promise.resolve(
+              session.run(normalizeFeeds(feeds, ort), ortRunOptions)
+            );
+            if (cancelled) throw new PPDetectionError("ABORTED", "\u63A8\u7406\u5DF2\u53D6\u6D88", { phase: "run" });
+            return result;
+          } catch (error) {
+            if (cancelled)
+              throw new PPDetectionError(
+                "ABORTED",
+                "\u63A8\u7406\u5DF2\u53D6\u6D88",
+                { phase: "run" },
+                { cause: error }
+              );
+            throw mapError(error, "run");
+          } finally {
+            runOptions.signal?.removeEventListener("abort", onAbort);
+          }
+        })();
+        const tracked = operation.then(
+          () => void 0,
+          () => void 0
+        );
+        activeRuns.add(tracked);
+        try {
+          return await operation;
+        } finally {
+          activeRuns.delete(tracked);
+        }
+      },
+      async dispose() {
+        if (disposePromise) return await disposePromise;
+        disposed = true;
+        disposePromise = (async () => {
+          await Promise.all([...activeRuns]);
+          await session.release?.();
+        })();
+        await disposePromise;
+      }
+    };
+  } catch (error) {
+    throw mapError(error, "create");
+  }
+}
+
+// src/runtime/capabilities.ts
+var WASM_SIMD_PROBE = new Uint8Array([
+  0,
+  97,
+  115,
+  109,
+  1,
+  0,
+  0,
+  0,
+  1,
+  5,
+  1,
+  96,
+  0,
+  1,
+  123,
+  3,
+  2,
+  1,
+  0,
+  10,
+  10,
+  1,
+  8,
+  0,
+  253,
+  15,
+  0,
+  0,
+  0,
+  11
+]);
+function hasWasmSimd(scope) {
+  try {
+    return typeof scope.WebAssembly !== "undefined" && scope.WebAssembly.validate(WASM_SIMD_PROBE);
+  } catch {
+    return false;
+  }
+}
+function hasWasmThreads(scope) {
+  try {
+    return typeof scope.SharedArrayBuffer !== "undefined" && typeof scope.Atomics !== "undefined" && scope.crossOriginIsolated === true;
+  } catch {
+    return false;
+  }
+}
+function probeCapabilities(options = {}) {
+  const scope = options.global ?? globalThis;
+  const navigatorValue = scope.navigator;
+  return {
+    webgpu: Boolean(navigatorValue && "gpu" in navigatorValue && navigatorValue.gpu),
+    worker: typeof scope.Worker === "function",
+    offscreenCanvas: typeof scope.OffscreenCanvas === "function",
+    wasmSimd: hasWasmSimd(scope),
+    wasmThreads: hasWasmThreads(scope)
+  };
+}
+
+// src/runtime/select-plan.ts
+function fail(code, message, details) {
+  throw new PPDetectionError(code, message, details);
+}
+function candidatesForBackend(requested, capabilities, allowFallback) {
+  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) {
+  const requestedBackend = options.backend ?? "auto";
+  const requestedPrecision = options.precision ?? "fp32";
+  const executionMode = options.executionMode ?? "main";
+  if (executionMode === "worker" && !capabilities.worker) {
+    fail("CAPABILITY_UNSUPPORTED", "\u8BF7\u6C42\u7684 worker \u4E0D\u53EF\u7528", { executionMode });
+  }
+  const variant3 = manifest.variants?.find(
+    (candidate) => candidate.precision === requestedPrecision && candidate.status !== "labs" && candidate.status !== "blocked"
+  );
+  if (!variant3) {
+    fail("MODEL_INCOMPATIBLE", `manifest \u6CA1\u6709\u53EF\u7528\u7684 ${requestedPrecision} \u7A33\u5B9A\u53D8\u4F53`, {
+      requestedPrecision
+    });
+  }
+  const candidates = candidatesForBackend(
+    requestedBackend,
+    capabilities,
+    options.allowFallback === true
+  ).filter((backend) => variant3.backends.includes(backend));
+  if (candidates.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];
+  return {
+    variantId: variant3.id,
+    requestedBackend,
+    actualBackend,
+    requestedPrecision,
+    actualPrecision: variant3.precision,
+    executionMode,
+    candidates: candidates.map((backend) => ({
+      variantId: variant3.id,
+      backend,
+      precision: variant3.precision,
+      executionMode
+    }))
+  };
+}
+
+// src/runtime/protocol.ts
+function transferableValues(value) {
+  const transferables = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (candidate) => {
+    if (!candidate || typeof candidate !== "object") return;
+    if (seen.has(candidate)) return;
+    seen.add(candidate);
+    if (candidate instanceof ArrayBuffer) {
+      transferables.add(candidate);
+      return;
+    }
+    if (ArrayBuffer.isView(candidate)) {
+      if (candidate.buffer instanceof ArrayBuffer) transferables.add(candidate.buffer);
+      return;
+    }
+    for (const child of Object.values(candidate)) visit(child);
+  };
+  visit(value);
+  return [...transferables];
+}
+
+// src/runtime/worker-bridge.ts
+var WorkerBridge = class {
+  constructor(worker) {
+    this.worker = worker;
+    worker.onmessage = (event) => this.handleResponse(event.data);
+    worker.onerror = (event) => this.shutdown(
+      new PPDetectionError("INFERENCE_FAILED", event.message || "Worker \u6267\u884C\u5931\u8D25", {
+        source: "worker"
+      })
+    );
+  }
+  worker;
+  pending = /* @__PURE__ */ new Map();
+  state = "active";
+  disposePromise;
+  terminated = false;
+  sequence = 0;
+  load(modelBytes, plan, options = {}) {
+    return this.request(
+      { type: "load", modelBytes, plan, ...options.ort ? { ort: options.ort } : {} },
+      [modelBytes],
+      options
+    );
+  }
+  run(input, options = {}) {
+    return this.request({ type: "run", input }, transferableValues(input), {
+      signal: options.signal,
+      onProgress: options.onProgress
+    });
+  }
+  dispose() {
+    if (this.disposePromise) return this.disposePromise;
+    if (this.state === "disposed") return Promise.resolve();
+    this.state = "disposing";
+    this.disposePromise = this.request({ type: "dispose" }, [], { allowDuringDispose: true }).then(() => void 0).finally(() => this.shutdown(new PPDetectionError("DISPOSED", "Worker \u5DF2\u91CA\u653E")));
+    return this.disposePromise;
+  }
+  request(payload, transfer, options = {}) {
+    if (this.state !== "active" && !(options.allowDuringDispose && this.state === "disposing")) {
+      return Promise.reject(new PPDetectionError("DISPOSED", "Worker \u5DF2\u91CA\u653E"));
+    }
+    if (options.signal?.aborted)
+      return Promise.reject(new PPDetectionError("ABORTED", "Worker \u63A8\u7406\u5DF2\u53D6\u6D88"));
+    const id = String(++this.sequence);
+    return new Promise((resolve, reject) => {
+      let posted = false;
+      const cleanup = () => options.signal?.removeEventListener("abort", onAbort);
+      const onAbort = () => {
+        if (!this.pending.delete(id)) return;
+        cleanup();
+        if (posted && payload.type === "run") this.sendCancel(id);
+        reject(new PPDetectionError("ABORTED", "Worker \u63A8\u7406\u5DF2\u53D6\u6D88"));
+      };
+      this.pending.set(id, { resolve, reject, cleanup, onProgress: options.onProgress });
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      if (options.signal?.aborted) {
+        onAbort();
+        return;
+      }
+      try {
+        this.worker.postMessage({ id, ...payload }, transfer);
+        posted = true;
+      } catch (error) {
+        this.pending.delete(id);
+        cleanup();
+        reject(
+          new PPDetectionError(
+            "INFERENCE_FAILED",
+            "\u5411 Worker \u53D1\u9001\u6D88\u606F\u5931\u8D25",
+            { requestType: payload.type },
+            { cause: error }
+          )
+        );
+      }
+    });
+  }
+  sendCancel(requestId) {
+    try {
+      this.worker.postMessage({ id: String(++this.sequence), type: "cancel", requestId }, []);
+    } catch {
+    }
+  }
+  handleResponse(response) {
+    if (response.type === "progress") {
+      this.pending.get(response.id)?.onProgress?.({
+        phase: response.phase,
+        status: response.status,
+        ...response.loadedBytes === void 0 ? {} : { loadedBytes: response.loadedBytes },
+        ...response.totalBytes === void 0 ? {} : { totalBytes: response.totalBytes }
+      });
+      return;
+    }
+    const request = this.pending.get(response.id);
+    if (!request) return;
+    this.pending.delete(response.id);
+    request.cleanup();
+    if (response.type === "result") request.resolve(response.result);
+    else
+      request.reject(
+        new PPDetectionError(
+          response.error.code,
+          response.error.message,
+          response.error.details ?? {}
+        )
+      );
+  }
+  failAll(error) {
+    for (const request of this.pending.values()) {
+      request.cleanup();
+      request.reject(error);
+    }
+    this.pending.clear();
+  }
+  shutdown(error) {
+    this.state = "disposed";
+    if (!this.terminated) {
+      this.terminated = true;
+      this.worker.terminate();
+    }
+    this.failAll(error);
+  }
+};
+
+// src/index.ts
+var CURRENT_SDK_VERSION = "0.1.0";
+function probePPDetectionCapabilities(options = {}) {
+  return probeCapabilities(options);
+}
+function now4() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function isRuntimeManifest(value) {
+  if (typeof value !== "object" || value === null || !("postprocessing" in value)) return false;
+  const variants = value.variants;
+  return Array.isArray(variants) && variants[0]?.sources !== void 0;
+}
+function isModelData(value) {
+  return typeof value === "object" && value !== null && "data" in value && "manifest" in value;
+}
+async function fetchJson(url2, signal) {
+  let response;
+  try {
+    response = await fetch(url2, { signal });
+  } catch (error) {
+    if (signal?.aborted || error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError") {
+      throw new PPDetectionError("ABORTED", "\u6A21\u578B\u6E05\u5355\u4E0B\u8F7D\u5DF2\u53D6\u6D88", { url: url2 }, { cause: error });
+    }
+    throw new PPDetectionError(
+      "MODEL_SOURCE_UNAVAILABLE",
+      "\u6A21\u578B\u6E05\u5355\u4E0B\u8F7D\u5931\u8D25",
+      { url: url2 },
+      { cause: error }
+    );
+  }
+  if (signal?.aborted) throw new PPDetectionError("ABORTED", "\u6A21\u578B\u6E05\u5355\u4E0B\u8F7D\u5DF2\u53D6\u6D88", { url: url2 });
+  if (!response.ok)
+    throw new PPDetectionError("MODEL_SOURCE_UNAVAILABLE", "\u6A21\u578B\u6E05\u5355\u8FD4\u56DE\u975E\u6210\u529F\u72B6\u6001", {
+      url: url2,
+      status: response.status
+    });
+  try {
+    const value = await response.json();
+    if (signal?.aborted) throw new PPDetectionError("ABORTED", "\u6A21\u578B\u6E05\u5355\u4E0B\u8F7D\u5DF2\u53D6\u6D88", { url: url2 });
+    return value;
+  } catch (error) {
+    if (error instanceof PPDetectionError) throw error;
+    if (signal?.aborted || error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError") {
+      throw new PPDetectionError("ABORTED", "\u6A21\u578B\u6E05\u5355\u4E0B\u8F7D\u5DF2\u53D6\u6D88", { url: url2 }, { cause: error });
+    }
+    throw new PPDetectionError(
+      "INVALID_MANIFEST",
+      "\u6A21\u578B\u6E05\u5355 JSON \u65E0\u6CD5\u89E3\u6790",
+      { url: url2 },
+      { cause: error }
+    );
+  }
+}
+function asRuntimeManifest(value) {
+  return isRuntimeManifest(value) ? parseDetectionManifest(value) : adaptModelManifest(parseModelManifest(value));
+}
+function simpleManifest(runtime) {
+  return {
+    id: runtime.model.id,
+    version: runtime.model.version,
+    variants: runtime.variants.map((variant3) => ({
+      id: variant3.id,
+      precision: variant3.precision,
+      quantization: variant3.quantization,
+      backends: variant3.backends,
+      status: variant3.status
+    }))
+  };
+}
+function modelInfo(runtime, variantId, source2) {
+  const variant3 = runtime.variants.find((candidate) => candidate.id === variantId);
+  if (!variant3)
+    throw new PPDetectionError("MODEL_INCOMPATIBLE", "\u8BF7\u6C42\u7684\u6A21\u578B\u53D8\u4F53\u4E0D\u5B58\u5728", { variantId });
+  return {
+    id: runtime.model.id,
+    version: runtime.model.version,
+    variantId: variant3.id,
+    precision: variant3.precision,
+    bytes: variant3.bytes,
+    parameterCount: variant3.parameterCount,
+    opset: variant3.opset,
+    source: {
+      kind: source2.kind,
+      revision: source2.revision,
+      bytes: source2.bytes,
+      sha256: source2.sha256
+    }
+  };
+}
+function workerUrl() {
+  const scriptUrl = globalThis.__PPDETECTION_SCRIPT_URL__;
+  if (scriptUrl) return new URL("./inference.worker.js", scriptUrl);
+  return new URL("./inference.worker.js", import.meta.url);
+}
+async function createPPDetection(options = {}) {
+  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();
+  options.onProgress?.({ phase: "capabilities", status: "complete" });
+  const requestedModel = options.model ?? options.manifest;
+  let runtimeManifest;
+  let memoryData;
+  options.onProgress?.({ phase: "manifest", status: "start" });
+  if (typeof requestedModel === "string") {
+    runtimeManifest = asRuntimeManifest(await fetchJson(requestedModel, options.signal));
+  } else if (isModelData(requestedModel)) {
+    runtimeManifest = asRuntimeManifest(requestedModel.manifest);
+    memoryData = requestedModel.data;
+  } else {
+    runtimeManifest = asRuntimeManifest(requestedModel);
+  }
+  options.onProgress?.({ phase: "manifest", status: "complete" });
+  const plan = selectExecutionPlan(
+    {
+      backend: options.backend,
+      precision: options.precision === "auto" ? void 0 : options.precision,
+      executionMode: options.executionMode,
+      allowFallback: options.allowFallback
+    },
+    capabilities,
+    simpleManifest(runtimeManifest)
+  );
+  const modelManager = new ModelManager({
+    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;
+    let variant3 = runtimeManifest.variants.find((candidate) => candidate.id === plan.variantId);
+    let loadTimings;
+    if (memoryData !== void 0) {
+      const [source2] = resolveModelSources(variant3, options.source ?? "auto");
+      if (!source2)
+        throw new PPDetectionError("MODEL_SOURCE_UNAVAILABLE", "\u6A21\u578B\u53D8\u4F53\u6CA1\u6709\u53EF\u7528\u6765\u6E90", {
+          variantId: variant3.id
+        });
+      await verifyModelIntegrity(memoryData, source2, options.signal);
+      modelBytes = memoryData;
+      actualSource = source2;
+      loadTimings = { sessionMs: 0, totalMs: now4() - loadStartedAt, integrityMs: 0 };
+    } else {
+      const loaded = await modelManager.load({
+        manifest: runtimeManifest,
+        variantId: plan.variantId,
+        sourceKind: options.source ?? "auto",
+        signal: options.signal,
+        onProgress: (progress) => options.onProgress?.({ phase: "model", status: "progress", ...progress })
+      });
+      modelBytes = loaded.bytes;
+      variant3 = loaded.variant;
+      actualSource = loaded.source;
+      loadTimings = { ...loaded.timings, sessionMs: 0, totalMs: now4() - loadStartedAt };
+    }
+    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]
+      };
+      options.onProgress?.({ phase: "session", status: "start" });
+      try {
+        if (candidate.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, {
+            onProgress: (event) => options.onProgress?.({
+              phase: "session",
+              status: event.status
+            }),
+            ort: {
+              wasmPaths: options.ort?.wasm?.paths,
+              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 = {
+            run(input, signal) {
+              return session.run(
+                { [input.inputName]: { data: input.data, dims: input.dims } },
+                { signal }
+              );
+            },
+            dispose: () => session.dispose()
+          };
+        }
+        selectedPlan = candidatePlan;
+        options.onProgress?.({ phase: "session", status: "complete" });
+        break;
+      } catch (error) {
+        const mapped = error instanceof PPDetectionError ? error : new PPDetectionError("SESSION_CREATE_FAILED", String(error));
+        const hasNext = options.allowFallback === true && candidate !== plan.candidates.at(-1);
+        try {
+          await executor?.dispose();
+        } catch {
+        }
+        executor = void 0;
+        try {
+          await activeBridge?.dispose();
+        } catch {
+        }
+        activeBridge = void 0;
+        if (!hasNext) {
+          throw mapped;
+        }
+        const fallback = {
+          cause: mapped.cause ?? mapped,
+          code: mapped.code,
+          message: mapped.message,
+          precision: candidate.precision,
+          provider: candidate.backend,
+          stage: "session",
+          variantId: candidate.variantId
+        };
+        fallbacks.push(fallback);
+        options.onProgress?.({ phase: "fallback", status: "complete", fallback });
+      }
+    }
+    if (!executor) throw new PPDetectionError("SESSION_CREATE_FAILED", "\u65E0\u6CD5\u521B\u5EFA\u68C0\u6D4B Session");
+    const loadedExecutor = executor;
+    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
+      },
+      loadTimings,
+      loadExecutor: () => Promise.resolve(loadedExecutor),
+      onProgress: options.onProgress,
+      clearCurrentModelCache: () => modelManager.clearCurrentModelCache(),
+      clearAllCache: () => modelManager.clearAllCache(),
+      getCacheEstimate: () => modelManager.getCacheEstimate(),
+      disposeResources: () => modelManager.dispose()
+    });
+    await detector.load({ signal: options.signal });
+    options.onProgress?.({ phase: "ready", status: "complete" });
+    return detector;
+  } catch (error) {
+    try {
+      await executor?.dispose();
+    } catch {
+    }
+    try {
+      await activeBridge?.dispose();
+    } catch {
+    }
+    try {
+      await modelManager.dispose();
+    } catch {
+    }
+    throw error;
+  }
+}
+async function clearModelCache() {
+  const manager = new ModelManager();
+  await manager.clearAllCache();
+  await manager.dispose();
+}
+
+export { CURRENT_SDK_VERSION, IndexedDBModelCache, MemoryModelCache, ModelManager, PPDetectionError, adaptModelManifest, clearModelCache, createOrtSession, createPPDetection, loadModelAsset, parseDetectionManifest, parseModelManifest, probeCapabilities, probePPDetectionCapabilities, resolveModelAsset, selectExecutionPlan };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map