tempest-react-sdk 0.69.0 → 0.70.0

package/dist/vision.d.ts

@@ -1,6 +1,15 @@
 import type * as ort from 'onnxruntime-web';
 import { RefObject } from 'react';
 
+/**
+ * Widen a model output to `Float32Array`, without copying when it already is.
+ *
+ * @param data A tensor's `data`, as ORT returned it.
+ * @returns The same values as a `Float32Array`. A float32 output is passed
+ *   through untouched; anything else is copied once.
+ */
+export declare function asFloat32Array(data: unknown): Float32Array;
+
 /**
  * Per-class NMS — boxes are suppressed only by other boxes of the same class.
  *
@@ -274,6 +283,13 @@ export declare class Classifier extends VisionTask {
     call(image: ImageInput, options?: ClassifierPredictOptions): Promise<ClassificationResults[]>;
     /** Run classification on a single image. */
     predict(image: ImageInput, options?: ClassifierPredictOptions): Promise<ClassificationResults[]>;
+    /**
+     * Resize and pack the image into the tensor the model expects.
+     *
+     * @param image The decoded input.
+     * @param canvas The opaque canvas it was decoded on, when there is one — see
+     *   {@link ResizePipeline.run}.
+     */
     private _preprocess;
     private _postprocess;
 }
@@ -475,6 +491,16 @@ export declare function decodeYolo(output: Float32Array, outputDims: readonly nu
  * mask coefficients) are ignored — callers can fetch them via the returned
  * {@link DecodedAnchors.anchorIndices}.
  *
+ * Candidates are found in two passes, mirroring the Python decoder. The first
+ * walks each class row contiguously and only *marks* anchors holding some score
+ * at or above the threshold — an anchor's best score clears the threshold
+ * exactly when one of its scores does, so no running maximum is needed and the
+ * hot loop never writes on a typical frame. The anchor-major scan it replaces
+ * read `numClasses` values spaced `numAnchors` apart for every one of the 8400
+ * anchors and cost ~1 ms even on a frame with no candidates. The winning class
+ * is then picked only for the marked anchors — a few hundred, not 8400 — with
+ * the same strict `>` that keeps the lowest class id on a tie.
+ *
  * @param data Flat per-anchor output, length `channels * numAnchors`.
  * @param dims Dims as reported by ORT, e.g. `[1, 84, 8400]` (det) or
  *   `[1, 116, 8400]` (seg). The leading batch dim must be 1.
@@ -510,6 +536,11 @@ export declare interface DecodeYoloOptions {
  *
  * Compatible with YOLOv8-seg / YOLOv11-seg.
  *
+ * The prototypes' batch axis is stripped here; the per-anchor batch axis is
+ * validated by {@link decodeYoloAnchors}. Each instance's box is mapped back
+ * into input-tensor coordinates and from there into the low-resolution
+ * prototype grid, and only the prototype pixels under it are assembled.
+ *
  * @param perAnchorData Flat `output0`, length `(4 + numClasses + numMaskCoefs) * numAnchors`.
  * @param perAnchorDims Dims as reported by ORT, e.g. `[1, 116, 8400]`.
  * @param prototypeData Flat `output1`, length `numMaskCoefs * maskH * maskW`.
@@ -538,6 +569,9 @@ export declare interface DecodeYoloSegOptions {
     readonly maskThreshold?: number;
 }
 
+/** Cache Storage bucket used when {@link OrtSessionOptions.cache} is `true`. */
+export declare const DEFAULT_MODEL_CACHE = "ort-vision-sdk-models";
+
 /**
  * Default execution provider preference order for browser ORT.
  *
@@ -546,6 +580,9 @@ export declare interface DecodeYoloSegOptions {
  */
 export declare const DEFAULT_PROVIDERS: readonly string[];
 
+/** The element type every task preprocesses to, and the fallback when unknown. */
+export declare const DEFAULT_TENSOR_TYPE = "float32";
+
 /**
  * Resolve a labels specification into an ordered array of class names.
  *
@@ -669,6 +706,10 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
        * is what lets the graph undo the letterbox transform internally and crop at
        * native resolution instead of from the downscaled copy. That one is **not**
        * letterboxed by definition, so it does not go through the fused path.
+       *
+       * @param image The decoded input.
+       * @param canvas The opaque canvas it was decoded on, when there is one — see
+       *   {@link LetterboxPipeline.run}.
        */
       private _preprocess;
       /**
@@ -803,6 +844,14 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
           * belongs to*, and collapsing them would lose one of the two.
           */
          readonly classification?: ClassificationResult | null;
+         /**
+          * Binary foreground mask for this object, shaped to `bbox` in original-image
+          * pixels — the same contract {@link SegmentationResult.mask} uses.
+          *
+          * Populated only by a `detect_segment_classify` pipeline, where a
+          * segmentation stage ran inside the crop. `null` everywhere else.
+          */
+         readonly mask?: Mask | null;
      }
 
      /**
@@ -928,8 +977,26 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
           * readback loop, and reuses its output buffer between frames. The buffer is
           * handed straight to ONNX Runtime, so {@link _pipeline.release} must not be
           * called until the run resolves.
+          *
+          * @param image The decoded input.
+          * @param canvas The opaque canvas it was decoded on, when there is one — see
+          *   {@link LetterboxPipeline.run}.
           */
          private _preprocess;
+         /**
+          * Assemble one detection.
+          *
+          * `croppedImage` is built on first read when the SDK owns the frame's pixels
+          * — see {@link memoize} for why. A frame the caller handed over as an
+          * `RGBImage` is cropped up front instead: its buffer is theirs, and a video
+          * loop refilling it would otherwise hand a late reader the wrong frame.
+          *
+          * @param original The decoded input.
+          * @param bbox Box in original-image coordinates.
+          * @param classId Predicted class.
+          * @param confidence Detection score.
+          * @param lazy Whether `croppedImage` may be deferred.
+          */
          private _buildResult;
          private _buildBoxes;
      }
@@ -1012,10 +1079,29 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
       * kept rather than dropped: guessing a provider away would be worse than
       * admitting ignorance about it.
       *
-      * @param requested Providers in preference order, already resolved.
-      * @returns The subset that is not ruled out, in the same order.
+      * The WebGPU adapter is only requested when `webgpu` is in the list. Asking
+      * unconditionally cost every WASM-only session a `requestAdapter()` round trip
+      * and, on a machine without a GPU, a "No available adapters" console warning
+      * per `create`.
+      *
+      * @param requested Providers in preference order, already resolved, as names
+      *   or config objects.
+      * @returns The subset that is not ruled out, in the same order and form.
       */
-     export declare function detectProviders(requested: readonly string[]): Promise<string[]>;
+     export declare function detectProviders<T extends ProviderSpec>(requested: readonly T[]): Promise<T[]>;
+
+     /**
+      * The structural surface of `Float16Array` this module needs.
+      *
+      * Declared here rather than pulled from `lib.es2025`: the package targets
+      * ES2022 so it builds for consumers on older TypeScript, and the only thing
+      * needed is "an array-like of numbers ORT recognises as half precision".
+      */
+     export declare interface Float16ArrayLike {
+         readonly length: number;
+         readonly buffer: ArrayBufferLike;
+         [index: number]: number;
+     }
 
      /**
       * Convert an HWC BGR uint8 buffer (OpenCV layout) to the SDK's HWC RGB.
@@ -1062,6 +1148,17 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
      /** Value of the `ovs.kind` metadata key for a detector→classifier pipeline. */
      export declare const FUSION_KIND_DETECT_CLASSIFY = "detect_classify";
 
+     /**
+      * Value of `ovs.kind` for a detector→segmenter→classifier pipeline.
+      *
+      * The segmenter runs inside each crop rather than over the whole frame: the
+      * detector finds the boxes, the bridge cuts them out, and the segmenter turns
+      * each crop into a foreground mask that gates the pixels the classifier sees.
+      * Fusing one is a build step on the Python side; the browser only loads the
+      * result.
+      */
+     export declare const FUSION_KIND_DETECT_SEGMENT_CLASSIFY = "detect_segment_classify";
+
      /**
       * Raised when a model cannot be driven as a fused detect→classify pipeline.
       *
@@ -1075,7 +1172,7 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
 
      /** Everything a fused pipeline declares about how it must be driven. */
      export declare interface FusionSpec {
-         /** Pipeline family. Only `"detect_classify"` exists today. */
+         /** Pipeline family — {@link FUSION_KIND_DETECT_CLASSIFY} or {@link FUSION_KIND_DETECT_SEGMENT_CLASSIFY}. */
          readonly kind: string;
          /** `[width, height]` the detector stage expects — the resolution to letterbox to. */
          readonly inputSize: readonly [number, number];
@@ -1103,8 +1200,39 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
          readonly sdkVersion: string;
          /** Whether driving this pipeline requires feeding the full-resolution input. */
          readonly needsSourceImage: boolean;
+         /** Whether this pipeline emits a {@link OUTPUT_MASKS} tensor. */
+         readonly hasMasks: boolean;
+         /** Class id → name for the segmenter's channels, or `null`. */
+         readonly segmenterNames: readonly string[] | null;
+         /**
+          * Probability above which a segmenter pixel counted as foreground.
+          *
+          * Baked into the graph at fusion time; reported so a caller can say what the
+          * masks mean.
+          */
+         readonly maskThreshold: number;
+         /** Whether the mask gated the crop before the classifier saw it. */
+         readonly maskApplied: boolean;
      }
 
+     /**
+      * Metadata key naming the level a model was graph-optimized at offline.
+      *
+      * Written by the Python SDK's `optimize_model`; both test suites pin the same
+      * string, so a rename on one side fails. See {@link OrtSession.create} for what
+      * the session does when it finds it.
+      */
+     export declare const GRAPH_OPTIMIZATION_KEY = "ort_vision_sdk.graph_optimization";
+
+     /**
+      * Whether this environment can build a half-precision tensor at all.
+      *
+      * @returns `true` when the runtime exposes `Float16Array`. ORT rejects any
+      *   other typed array for a `float16` tensor, so a `false` here means half
+      *   precision is unreachable in this browser no matter what the model declares.
+      */
+     export declare function hasFloat16Array(): boolean;
+
      /** Mean that leaves an image untouched — what an Ultralytics classifier expects. */
      export declare const IDENTITY_MEAN: readonly [number, number, number];
 
@@ -1112,7 +1240,7 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
      export declare const IDENTITY_STD: readonly [number, number, number];
 
      /** Anything {@link loadImage} accepts as an image input. */
-     export declare type ImageInput = string | Blob | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap | ImageData | RGBImage;
+     export declare type ImageInput = string | Blob | HTMLImageElement | HTMLVideoElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap | VideoFrame | ImageData | RGBImage;
 
      /** Raised when an input image cannot be decoded into the canonical format. */
      export declare class ImageLoadError extends OrtVisionError {
@@ -1235,26 +1363,43 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
           * into — see {@link ReusableBuffer}.
           *
           * @param image Source image in the SDK's canonical HWC RGB layout.
+          * @param canvas Optional drawable already holding exactly `image`'s pixels at
+          *   `image.width × image.height`, fully opaque. When given it is drawn
+          *   straight into the target, skipping the RGB→RGBA rebuild and the
+          *   `putImageData` onto the scratch canvas — two full-resolution passes per
+          *   frame. The tasks pass the canvas `loadImage` decoded onto; a caller with a
+          *   translucent source must not, since the result would composite its alpha.
           */
-         run(image: RGBImage): FusedLetterboxResult;
+         run(image: RGBImage, canvas?: CanvasImageSource | null): FusedLetterboxResult;
          /**
           * Mark the reusable buffer free again.
           *
           * Call it once the tensor built from a {@link run} result has been handed to
           * ONNX Runtime and the run has resolved — after that the values are inside
           * the WASM heap and the buffer can be overwritten.
+          *
+          * Pass the result being released when several runs can be outstanding at
+          * once. A result that got a fresh allocation (`reused: false`) holds nothing
+          * of the pipeline's, so releasing it is a no-op; without that check, the
+          * caller finishing with a fresh buffer would free the shared one while
+          * another caller still had its frame in it. Called without an argument it
+          * frees the shared buffer unconditionally, as before.
+          *
+          * @param result The {@link run} result being released.
           */
-         release(): void;
+         release(result?: {
+             readonly reused: boolean;
+         }): void;
          /**
-          * Grow the scratch source canvas to fit an image, reusing it when possible.
+          * Paint an image onto the scratch source canvas and return that canvas.
           *
-          * A canvas is only reallocated when a frame arrives at a different size than
-          * the last one, which for a camera or video source is never after the first.
+          * The canvas is only reallocated when a frame arrives at a different size
+          * than the last one, which for a camera or video source is never after the
+          * first.
           *
-          * @param width Source width in pixels.
-          * @param height Source height in pixels.
+          * @param image Source image in the SDK's canonical HWC RGB layout.
           */
-         private _ensureSource;
+         private _paintSource;
      }
 
      export declare interface LetterboxResult {
@@ -1284,6 +1429,10 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
      /**
       * Load an image from any supported source into a HWC uint8 RGB array.
       *
+      * A video element must have its current frame available (`readyState >= 2`);
+      * the frame showing at the time of the call is the one decoded. A `VideoFrame`
+      * is read but not closed — it belongs to the caller.
+      *
       * @throws {@link ImageLoadError} if the source cannot be decoded or has an unsupported shape.
           */
       export declare function loadImage(source: ImageInput): Promise<RGBImage>;
@@ -1417,6 +1566,13 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
        * @returns Indices of kept boxes, in descending score order. Boxes tied on
        *   score are visited lowest-index first, so the survivor of a tie is
        *   deterministic and matches both `torchvision` and the Python SDK.
+       *
+       * The boxes are copied once into score order, so the inner loop walks a
+       * contiguous `Float32Array` instead of hopping through `order` into the caller's
+       * layout. A pair with no horizontal overlap is skipped before the vertical
+       * extent is computed: its IoU is `0`, which suppresses nothing for any
+       * non-negative threshold — the shortcut is gated on that so a negative
+       * threshold keeps the exact semantics.
        */
       export declare function nms(boxes: Float32Array, scores: Float32Array, iouThreshold: number): Int32Array;
 
@@ -1512,7 +1668,22 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
            * `webgpu` on a device without it runs on WASM and is told nothing.
            */
           readonly requestedProviders: readonly string[];
+          /**
+           * Tensor type each input declares, keyed by input name.
+           *
+           * Read from the model file, not from the session: `inputMetadata` is
+           * `undefined` on `onnxruntime-web` 1.20.1. Empty when the bytes were never
+           * in hand — a URL loaded with `readMetadata: false` — in which case every
+           * feed is built as float32, the behaviour before this existed.
+           */
+          private readonly _inputTypes;
           private constructor();
+          /**
+           * Tail of the run queue: settles when the latest queued run has finished.
+           *
+           * See {@link run} for why runs are serialized.
+           */
+          private _runQueue;
           /**
            * Load an ONNX model into an ORT inference session.
            *
@@ -1526,12 +1697,35 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
            * it — on a phone that was the difference between a session and
            * `Can't create a session. failed to allocate a buffer of size N`.
            *
+           * The provider probe and the model download run concurrently: neither
+           * depends on the other, and on a real GPU `requestAdapter()` is not free.
+           * When the model is downloaded here, ORT's runtime is started alongside the
+           * download too — see {@link warmRuntime}.
+           *
+           * A model whose metadata carries {@link GRAPH_OPTIMIZATION_KEY} was already
+           * optimized offline by the Python SDK's `optimize_model`, so it is loaded
+           * with `graphOptimizationLevel: "disabled"` instead of paying the optimizer a
+           * second time — measured on a YOLO11n-seg under WASM, 29 ms of session
+           * creation down to 12 ms with unchanged inference time. An explicit
+           * `graphOptimizationLevel` in `sessionOptions` always wins. The mark is read
+           * with the rest of the metadata, so `readMetadata: false` skips it too.
+           *
            * @param model Either a URL string, or a `Uint8Array`/`ArrayBuffer` containing the model bytes.
            * @param options Provider list, pass-through `SessionOptions`, and whether to
            *   read the model's metadata map (see {@link OrtSessionOptions.readMetadata}).
            * @throws {@link ModelLoadError} if the model cannot be loaded.
                */
            static create(model: ModelSource, options?: OrtSessionOptions): Promise<OrtSession>;
+           /**
+            * Tensor type each input declares, in declaration order.
+            *
+            * `"float32"` for a normal export, `"float16"` for one exported with
+            * `half=True`. ORT matches a feed's type against this exactly, so the tasks
+            * read it and convert at the feed boundary.
+            */
+           get inputDtypes(): readonly string[];
+           /** Tensor type the first input declares. */
+           get inputDtype(): string;
            /** Names of the model's inputs, in declaration order. */
            get inputNames(): readonly string[];
            /** Name of the first (and usually only) input. */
@@ -1588,855 +1782,1037 @@ export declare const DEFAULT_PROVIDERS: readonly string[];
            /**
             * Run inference and return all outputs.
             *
+            * Runs on one session are serialized. ONNX Runtime Web refuses a second
+            * `run` while one is in flight — it rejects with `Session already started` —
+            * so two overlapping `predict()` calls on the same task used to fail. Queued
+            * here, they overlap where they can: while one run executes (in a worker,
+            * with `env.wasm.proxy`, or on the GPU), the next `predict()` decodes and
+            * preprocesses its frame and only waits for its turn at the runtime. A run
+            * that fails does not block the ones behind it.
+            *
             * @param feeds Map of input name to `ort.Tensor`. Keys must match {@link inputNames}.
             * @throws {@link InferenceError} if ORT raises any error during execution.
                 */
             run(feeds: Record<string, ort.Tensor>): Promise<Record<string, ort.Tensor>>;
-           }
-
-           export declare interface OrtSessionOptions {
-               /**
-                * Execution providers in preference order. `undefined` uses {@link DEFAULT_PROVIDERS}.
-                *
-                * Naming one explicitly also opts into a `console.warn` when this browser
-                * cannot offer it, instead of falling back in silence.
-                */
-               readonly providers?: readonly string[];
-               /** Optional ORT session options forwarded to `InferenceSession.create`. */
-               readonly sessionOptions?: ort.InferenceSession.SessionOptions;
-               /**
-                * Whether to read the model's custom metadata map (`names`, `task`, `imgsz`).
-                * Defaults to `true`.
-                *
-                * The runtime does not expose that map, so it is read from the file itself —
-                * which means a URL model is fetched here and handed to ORT as bytes instead
-                * of letting ORT fetch it. That is the same single download either way, and
-                * it is what lets a task resolve its labels off the model. Set to `false` to
-                * keep the URL path untouched and leave {@link OrtSession.metadata} empty.
-                *
-                * `false` is also the escape hatch when a device cannot afford the bytes: the
-                * fetched buffer is dropped before ORT builds the graph (see
-                * {@link OrtSession.create}), but ORT's own load path still keeps the model out
-                * of reach of anything the SDK holds. A session built this way resolves its
-                * input size from the graph as usual — only the class names are lost, so a
-                * caller taking this route has to pass `labels` itself.
-                */
-               readonly readMetadata?: boolean;
-           }
-
-           /** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */
-           /**
-            * Exceptions raised by the SDK.
-            *
-            * All exceptions inherit from {@link OrtVisionError}, so callers can catch
-            * the base class to handle any SDK-originated failure uniformly.
-            */
-           export declare class OrtVisionError extends Error {
-               constructor(message: string, options?: ErrorOptions);
-           }
-
-           /**
-            * Name of the `[K, 4]` float32 xyxy output, in **letterboxed** input pixels.
-            *
-            * A file fused by `ort-vision-sdk` 0.9.0 or later reports the box that was
-            * actually classified: clamped to the image the crop came from, exactly as
-            * RoiAlign received it. Older files report the raw box, so one that ran off the
-            * frame draws a rectangle wider than the region the classifier saw.
-            */
-           export declare const OUTPUT_BOXES = "boxes";
-
-           /** Name of the `[K]` int64 detector-class output. */
-           export declare const OUTPUT_CLASSES = "classes";
-
-           /** Name of the `[1]` int64 output holding how many of the `K` rows are real. */
-           export declare const OUTPUT_NUM_DETECTIONS = "num_detections";
-
-           /** Name of the `[K, numClassifierClasses]` float32 classifier output, one row per box. */
-           export declare const OUTPUT_PROBS = "probs";
-
-           /** Name of the `[K]` float32 detection-confidence output. */
-           export declare const OUTPUT_SCORES = "scores";
-
-           /**
-            * Parse a `repr`-encoded `dict[int, str]` class map.
-            *
-            * Split out of {@link modelNames} because the same encoding is reused by a
-            * fused pipeline, which carries one class map per stage and therefore cannot
-            * store both under the single `names` key Ultralytics uses.
-            *
-            * @param encoded The encoded map — e.g. `"{0: 'deworm', 1: 'not_deworm'}"`.
-            * @returns Class names in class-id order, or `null` when the value is missing,
-            *   unparseable, not a `dict`, or not keyed by contiguous integers from zero.
-            */
-           export declare function parseNames(encoded: string | undefined): readonly string[] | null;
-
-           /**
-            * Top-k classification probabilities for a single image.
-            *
-            * Mirrors Ultralytics' `Probs` interface.
-            */
-           export declare class Probs {
-               readonly data: Float32Array;
-               /** @param data `[numClasses]` per-class probabilities, indexed by class id. */
-               constructor(data: Float32Array);
-               /** Number of classes. */
-               get length(): number;
-               /** `[numClasses]` shape of the underlying vector. */
-               get shape(): readonly [number];
-               /** Index of the most probable class. */
-               get top1(): number;
-               /** Probability of the top-1 class. */
-               get top1conf(): number;
-               /**
-                * Indices of the top-5 most probable classes, descending.
-                *
-                * The array is the memoised selection itself, not a copy — reading it twice
-                * hands back the same object. Treat it as read-only: writing into it edits
-                * what every later read of this `Probs` returns.
-                */
-               get top5(): Int32Array;
-               /**
-                * Probabilities of the top-5 classes, descending.
-                *
-                * Shares the memoised selection with {@link Probs.top5}, under the same
-                * read-only caveat.
-                */
-               get top5conf(): Float32Array;
-               private _cache;
-               /**
-                * Memoised {@link Probs._topK}.
-                *
-                * `top5` and `top5conf` are separate getters over the same selection, so a
-                * caller reading both would otherwise pay for it twice — once per frame, in
-                * a camera loop. The probabilities a `Probs` was built from do not change,
-                * so the result is computed once per `k` and kept.
-                *
-                * @param k - How many classes to select.
-                * @returns The cached selection for that `k`.
-                */
-               private _top;
-               /**
-                * Select the `k` highest probabilities without ordering the rest.
-                *
-                * A full sort to read five entries out of a thousand-class vector costs
-                * O(n log n) plus an index array the size of the vector; keeping `k` slots
-                * ordered by insertion and scanning once costs O(n·k) with no allocation
-                * beyond the result. Measured on 1000 classes over 2000 iterations, 134.5 µs
-                * against 1.5 µs for the same output.
-                *
-                * Ties keep the lower class index first, matching the stable sort this
-                * replaced: a candidate only displaces an entry it is strictly greater
-                * than. That is also what keeps this selection in step with the Python
-                * SDK's `np.argsort(-data, kind="stable")`, where the sort is C and the
-                * cost this avoids does not arise.
-                *
-                * @param k - How many classes to select.
-                * @returns Indices and probabilities, descending by probability.
-                */
-               private _topK;
-           }
-
-           /** Raised when a requested execution provider is not available. */
-           export declare class ProviderNotAvailableError extends OrtVisionError {
-           }
-
-           /**
-            * Read a pipeline spec out of a model's custom metadata.
-            *
-            * Individual malformed entries fall back to the value a fusion would have used
-            * by default — a single bad float is not a reason to reject an otherwise
-            * loadable pipeline. A malformed resolution is fatal, because there is no safe
-            * default for one.
-            *
-            * @param metadata A model's custom metadata map, as read by
-            *   {@link readModelMetadata}.
-            * @returns The decoded spec, or `null` when the model is not a fused pipeline —
-            *   it carries no `ovs.kind` entry, or one naming a pipeline kind this version
-            *   does not know how to drive.
-            */
-           export declare function readFusionSpec(metadata: Readonly<Record<string, string>> | undefined): FusionSpec | null;
-
-           /** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */
-           /**
-            * Read the metadata an exporter baked into a `.onnx` file.
-            *
-            * `onnxruntime-web` exposes input/output metadata but **not** the model's
-            * custom metadata map, which is where Ultralytics writes `names`, `task` and
-            * `imgsz`. The Python SDK gets it for free from
-            * `InferenceSession.get_modelmeta().custom_metadata_map`; in the browser the
-            * only way to the same information is to read it out of the file, so this
-            * module walks just enough of the ModelProto wire format to collect
-            * `metadata_props`.
-            *
-            * It never throws and never allocates unbounded: a truncated, hostile or
-            * simply unexpected file yields an empty map, and every caller treats that as
-            * "the model says nothing", falling back to what it was given.
-            */
-           /**
-            * Collect a model's custom metadata map straight out of its bytes.
-            *
-            * @param model The `.onnx` file contents.
-            * @returns Key/value metadata — `names`, `task`, `imgsz`, ... for an
-            *   Ultralytics export — or an empty object when the file carries none or
-            *   cannot be walked.
-            */
-           export declare function readModelMetadata(model: Uint8Array | ArrayBufferLike): Readonly<Record<string, string>>;
-
-           /**
-            * Turn an empty result into an error, when the caller asked for that.
-            *
-            * Shared by every task that can come back with nothing — {@link Detector},
-            * {@link Segmenter} and {@link DetectClassify} — so the three agree on when
-            * they throw and on what the message says. The message names the two settings
-            * that decide the outcome, because "no detections" on its own leaves the reader
-            * unable to tell a blank image from a threshold set too high.
-            *
-            * @param count How many detections survived every filter.
-            * @param options The flag for this call, the threshold actually applied (after
-            *   any per-call override), the class allowlist if one narrowed the search, and
-            *   the source path when the input was one.
-            * @throws {@link NoDetectionsError} when the flag is set and `count` is zero.
-                */
-            export declare function requireDetections(count: number, options: {
-                readonly raiseOnEmpty: boolean;
-                readonly confThreshold: number;
-                readonly classes: readonly number[] | undefined;
-                readonly path: string | null;
-            }): void;
-
-            /** Resize an image to `(targetWidth, targetHeight)` using high-quality canvas resampling. */
-            export declare function resize(image: RGBImage, targetWidth: number, targetHeight: number): RGBImage;
-
             /**
-             * Reusable stretch-resize → normalized tensor pipeline for one target size.
-             *
-             * The classification counterpart of {@link LetterboxPipeline}. A classifier
-             * stretches to the model's square input instead of letterboxing into it — no
-             * padding, no scale to invert later, because nothing is mapped back onto the
-             * source image afterwards. That difference is why it cannot simply reuse the
-             * letterbox path.
+             * Execute one run immediately; only {@link run}'s queue calls this.
              *
-             * What it does share is the technique. The composable route
-             * (`resize` → `normalize` → `toCHW`) allocates an `RGBImage` and two
-             * `Float32Array`s and walks each end to end on every call: about 1.4 MB of
-             * fresh garbage per 224×224 `predict()`, produced at the exact moment a phone
-             * near its memory ceiling can least afford it. Here one `drawImage` resizes,
-             * and one loop reads the resulting RGBA and writes normalized planar float32
-             * into a buffer held across calls.
-             *
-             * Create one per task, not per frame.
-             */
-            export declare class ResizePipeline {
-                private readonly _targetWidth;
-                private readonly _targetHeight;
-                private readonly _mean;
-                private readonly _std;
-                private readonly _buffer;
-                private _target;
-                private _targetContext;
-                private _source;
-                private _sourceContext;
-                /**
-                 * @param targetWidth Model input width in pixels.
-                 * @param targetHeight Model input height in pixels.
-                 * @param mean Per-channel RGB mean in `[0, 1]`. Defaults to no shift.
-                 * @param std Per-channel RGB standard deviation. Defaults to no scaling.
+             * @param feeds Map of input name to `ort.Tensor`.
+             * @throws {@link InferenceError} if ORT raises any error during execution.
                  */
-                constructor(targetWidth: number, targetHeight: number, mean?: readonly [number, number, number], std?: readonly [number, number, number]);
-                /** The `[width, height]` this pipeline resizes into. */
-                get targetSize(): readonly [number, number];
+             private _runNow;
+             /**
+              * Rebuild any feed whose type does not match what its input declares.
+              *
+              * ORT matches feed types against the graph exactly: a float32 tensor against
+              * a `half=True` export fails the run with `Unexpected input data type`. Every
+              * preprocessing path in this SDK produces `Float32Array`, on purpose — the
+              * normalization arithmetic belongs in single precision — so the conversion
+              * happens here, once, at the only boundary all of them pass through. A feed
+              * that already carries the declared type is handed on untouched, so a caller
+              * building its own half tensor pays nothing.
+              *
+              * @param feeds The tensors to run with.
+              * @returns The same mapping, with mismatched float32 feeds converted.
+              */
+             private _asDeclaredTypes;
+            }
+
+            export declare interface OrtSessionOptions {
                 /**
-                 * Resize an image to the target size and write it as normalized planar float32.
+                 * Execution providers in preference order. `undefined` uses {@link DEFAULT_PROVIDERS}.
                  *
-                 * An image that already arrives at the target size skips the canvas entirely
-                 * and is read straight out of its packed RGB — which is both faster and what
-                 * keeps the result identical to `resize()`, whose own fast path returns the
-                 * input untouched.
+                 * Each entry is a name (`"webgpu"`, `"wasm"`) or ORT's config object for that
+                 * provider, which passes provider options through untouched —
+                 * `{ name: "webgpu", preferredLayout: "NHWC" }`.
                  *
-                 * Buffer reuse follows {@link ReusableBuffer}: held across calls, replaced when
-                 * a consumer detached it by transferring the tensor.
-                 *
-                 * @param image Source image in the SDK's canonical HWC RGB layout.
+                 * Naming one explicitly also opts into a `console.warn` when this browser
+                 * cannot offer it, instead of falling back in silence.
                  */
-                run(image: RGBImage): FusedResizeResult;
+                readonly providers?: readonly ProviderSpec[];
                 /**
-                 * Mark the reusable buffer free again.
+                 * Keep a URL model in the browser's Cache Storage between page loads.
+                 *
+                 * `true` uses the {@link DEFAULT_MODEL_CACHE} bucket; a string names the
+                 * bucket. A later `create` with the same URL reads the bytes from the cache
+                 * instead of the network — for a model of several megabytes, the bulk of
+                 * what a returning visitor waits for. Defaults to `false`.
                  *
-                 * Call it once the tensor built from a {@link run} result has been handed to
-                 * ONNX Runtime and the run has resolved — after that the values are inside
-                 * the WASM heap and the buffer can be overwritten.
+                 * The URL is the cache key and nothing expires it: publish a changed model
+                 * under a new URL (`yolo.v2.onnx`, `?v=2`) or a new bucket name, or delete
+                 * the bucket with `caches.delete(name)`. Ignored for models passed as bytes,
+                 * and silently skipped where Cache Storage is unavailable (non-secure
+                 * contexts, blocked site data).
                  */
-                release(): void;
+                readonly cache?: boolean | string;
+                /** Optional ORT session options forwarded to `InferenceSession.create`. */
+                readonly sessionOptions?: ort.InferenceSession.SessionOptions;
                 /**
-                 * Build the target canvas on first use.
+                 * Whether to read the model's custom metadata map (`names`, `task`, `imgsz`).
+                 * Defaults to `true`.
                  *
-                 * Lazily, so a pipeline constructed where no canvas implementation exists
-                 * (a Node test, a worker without OffscreenCanvas) only fails if it is asked
-                 * to resize something.
+                 * The runtime does not expose that map, so it is read from the file itself —
+                 * which means a URL model is fetched here and handed to ORT as bytes instead
+                 * of letting ORT fetch it. That is the same single download either way, and
+                 * it is what lets a task resolve its labels off the model. Set to `false` to
+                 * keep the URL path untouched (unless {@link cache} is set, which needs the
+                 * bytes) and leave {@link OrtSession.metadata} empty.
+                 *
+                 * `false` is also the escape hatch when a device cannot afford the bytes: the
+                 * fetched buffer is dropped before ORT builds the graph (see
+                 * {@link OrtSession.create}), but ORT's own load path still keeps the model out
+                 * of reach of anything the SDK holds. A session built this way resolves its
+                 * input size from the graph as usual — only the class names are lost, so a
+                 * caller taking this route has to pass `labels` itself.
                  */
-                private _ensureTarget;
-                /** Grow the scratch source canvas to fit an image, reusing it when possible. */
-                private _ensureSource;
+                readonly readMetadata?: boolean;
             }
 
+            /** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */
             /**
-             * Resize an image into normalized planar float32 without keeping any state.
-             *
-             * The allocation-free path is {@link ResizePipeline}; this is the one-shot
-             * form, for a caller who wants the fused behaviour without owning a pipeline.
+             * Exceptions raised by the SDK.
              *
-             * @param image Source image in the SDK's canonical HWC RGB layout.
-             * @param targetWidth Model input width in pixels.
-             * @param targetHeight Model input height in pixels.
-             * @param mean Per-channel RGB mean in `[0, 1]`. Defaults to no shift.
-             * @param std Per-channel RGB standard deviation. Defaults to no scaling.
+             * All exceptions inherit from {@link OrtVisionError}, so callers can catch
+             * the base class to handle any SDK-originated failure uniformly.
              */
-            export declare function resizeToTensorData(image: RGBImage, targetWidth: number, targetHeight: number, mean?: readonly [number, number, number], std?: readonly [number, number, number]): FusedResizeResult;
-
-            /** What {@link resolveNormalization} settled on. */
-            export declare interface ResolvedNormalization {
-                /** The preset name, or `"custom"` when the caller supplied the values. */
-                readonly name: string;
-                /** Per-channel mean to subtract. */
-                readonly mean: readonly [number, number, number];
-                /** Per-channel deviation to divide by. */
-                readonly std: readonly [number, number, number];
+            export declare class OrtVisionError extends Error {
+                constructor(message: string, options?: ErrorOptions);
             }
 
             /**
-             * Decide the input size a task will preprocess to.
+             * Name of the `[K, 4]` float32 xyxy output, in **letterboxed** input pixels.
              *
-             * Precedence is graph → caller → fallback. The graph wins over an explicit
-             * `inputSize` because a static shape is not a preference, it is what ORT will
-             * accept: honoring the caller there would only turn a fixable mismatch into a
-             * failed run. A disagreement is a configuration bug in the caller, so it is
-             * reported through `console.warn` instead of being swallowed.
-             *
-             * @param options Graph shape, requested size and per-task fallback.
-             * @returns The `[width, height]` to preprocess to.
+             * A file fused by `ort-vision-sdk` 0.9.0 or later reports the box that was
+             * actually classified: clamped to the image the crop came from, exactly as
+             * RoiAlign received it. Older files report the raw box, so one that ran off the
+             * frame draws a rectangle wider than the region the classifier saw.
              */
-            export declare function resolveInputSize(options: ResolveInputSizeOptions): readonly [number, number];
-
-            export declare interface ResolveInputSizeOptions {
-                /** Declared shape of the model's image input, from {@link declaredShapesFrom}. */
-                readonly graphShape?: DeclaredShape;
-                /** Size the caller asked for, if any. */
-                readonly requested?: readonly [number, number];
-                /** Size to use when neither the graph nor the caller pins one. */
-                readonly fallback: readonly [number, number];
-            }
+            export declare const OUTPUT_BOXES = "boxes";
 
-            export declare function resolveLabels(spec: LabelSpec, options?: ResolveLabelsOptions): readonly string[];
-
-            export declare interface ResolveLabelsOptions {
-                /**
-                 * Expected number of classes.
-                 *
-                 * - When `spec` is `null`/`undefined`, this is required to auto-generate names.
-                 * - When `spec` is provided, it validates that the resolved length matches.
-                 */
-                readonly numClasses?: number;
-            }
+            /** Name of the `[K]` int64 detector-class output. */
+            export declare const OUTPUT_CLASSES = "classes";
 
             /**
-             * Settle which `mean`/`std` to apply, and what to call the choice.
-             *
-             * Explicit `mean`/`std` always win — they are the escape hatch for a model whose
-             * preprocessing neither preset describes. Anything they leave open falls back to
-             * the preset, so passing only a `mean` does not silently reset the deviation
-             * to 1.
+             * Name of the `(K, 1, cropH, cropW)` float32 mask output. Only on a
+             * `detect_segment_classify` pipeline.
              *
-             * Warns (via `console.warn`) when the model is an Ultralytics export and the
-             * supplied values are not the identity it was trained with. Nothing fails in
-             * that case: the prediction has the right shape and is simply less accurate,
-             * which is exactly why it is worth saying out loud.
-             *
-             * @param metadata The model's custom metadata map, read to detect the family.
-             * @param options The preset asked for, plus any explicit `mean`/`std`.
-             * @throws {RangeError} If `normalization` is not a known preset, or names one
-             *   while `mean`/`std` are also supplied — two answers to the same question.
+             * The mask lives in the **crop's** coordinate space, not the original image's,
+             * because that is where the segmenter computed it. Values are 0 or 1 after
+             * thresholding; padded rows are all-zero, like every other output.
              */
-            export declare function resolveNormalization(metadata: Readonly<Record<string, string>>, options?: {
-                readonly normalization?: Normalization;
-                readonly mean?: readonly [number, number, number];
-                readonly std?: readonly [number, number, number];
-            }): ResolvedNormalization;
+            export declare const OUTPUT_MASKS = "masks";
 
-            /**
-             * Resolve the execution providers to pass to `InferenceSession.create`.
-             *
-             * @param requested Explicit provider list in preference order; `undefined` returns the default.
-             */
-            export declare function resolveProviders(requested?: readonly string[]): string[];
+            /** Name of the `[1]` int64 output holding how many of the `K` rows are real. */
+            export declare const OUTPUT_NUM_DETECTIONS = "num_detections";
 
-            /** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */
-            /**
-             * Public output types returned by the SDK's vision tasks.
-             *
-             * These types form the contract between the SDK and its callers. They mirror
-             * the Python `ort-vision-sdk` output dataclasses 1-to-1.
-             *
-             * Naming is intentionally compatible with the Ultralytics / torchvision idiom
-             * (`cls`, `conf`, `box`, `xyxy`, `xywh`, normalized variants) so code ported
-             * from those projects keeps working with minimal edits. The original verbose
-             * names (`classId`, `className`, `confidence`, `bbox`) are still populated for
-             * backwards compatibility.
-             */
-            /**
-             * HWC RGB uint8 image — the canonical image format used across the SDK.
-             *
-             * `data.length` must equal `width * height * 3`. The buffer is laid out row
-             * by row, top-to-bottom, with each pixel as `[R, G, B]`.
-             */
-            export declare class RGBImage {
-                readonly data: Uint8Array;
-                readonly width: number;
-                readonly height: number;
-                constructor(data: Uint8Array, width: number, height: number);
-            }
+            export declare const OUTPUT_PROBS = "probs";
 
-            /**
-             * Single segmented instance produced by an instance-segmentation model.
-             *
-             * Mirrors {@link DetectionResult} and adds the per-instance binary mask
-             * plus a "ready-to-display" background-removed crop.
-             */
-            export declare interface SegmentationResult {
-                readonly classId: number;
-                readonly className: string;
-                readonly confidence: number;
-                readonly bbox: BoundingBox;
-                /** Alias for `classId` (Ultralytics-style). */
-                readonly cls: number;
-                /** Alias for `className`. */
-                readonly name: string;
-                /** Alias for `confidence` (Ultralytics-style). */
-                readonly conf: number;
-                /** Alias for `bbox` (Ultralytics-style). */
-                readonly box: BoundingBox;
-                /**
-                 * Binary mask cropped to `bbox`. Values are `0` (background) or `255`
-                 * (foreground). Empty boxes yield a zero-sized `Mask`.
-                 */
-                readonly mask: Mask;
-                /**
-                 * The original image cropped to `bbox` with background pixels (where
-                 * `mask.data[i] === 0`) zeroed out. Empty boxes yield a zero-sized
-                 * `RGBImage`.
-                 */
-                readonly segmentedImage: RGBImage;
-            }
+            /** Name of the `[K]` float32 detection-confidence output. */
+            export declare const OUTPUT_SCORES = "scores";
 
             /**
-             * Per-image instance-segmentation envelope (Ultralytics-style `Results`).
+             * Parse a `repr`-encoded `dict[int, str]` class map.
+             *
+             * Split out of {@link modelNames} because the same encoding is reused by a
+             * fused pipeline, which carries one class map per stage and therefore cannot
+             * store both under the single `names` key Ultralytics uses.
              *
-             * Iterating yields per-instance {@link SegmentationResult} entries. `boxes`
-             * and `masks` mirror Ultralytics' bulk-array views.
+             * @param encoded The encoded map — e.g. `"{0: 'deworm', 1: 'not_deworm'}"`.
+             * @returns Class names in class-id order, or `null` when the value is missing,
+             *   unparseable, not a `dict`, or not keyed by contiguous integers from zero.
              */
-            export declare class SegmentationResults implements Iterable<SegmentationResult> {
-                readonly boxes: Boxes;
-                readonly masks: Masks;
-                readonly detections: readonly SegmentationResult[];
-                readonly names: Readonly<Record<number, string>>;
-                readonly origImg: RGBImage;
-                readonly origShape: readonly [number, number];
-                readonly path: string | null;
-                readonly speed: Readonly<Speed>;
-                constructor(boxes: Boxes, masks: Masks, detections: readonly SegmentationResult[], names: Readonly<Record<number, string>>, origImg: RGBImage, origShape: readonly [number, number], path?: string | null, speed?: Readonly<Speed>);
-                /** Number of surviving instances. */
-                get length(): number;
-                /** Index into the per-instance results. */
-                get(index: number): SegmentationResult | undefined;
-                [Symbol.iterator](): Iterator<SegmentationResult>;
-            }
+            export declare function parseNames(encoded: string | undefined): readonly string[] | null;
 
             /**
-             * Instance segmenter for YOLO seg ONNX models (v8-seg / v11-seg / ...).
-             *
-             * The model is expected to expose two outputs:
-             *
-             * 1. `output0`: `(1, 4 + numClasses + numMaskCoefs, numAnchors)` — per-anchor
-             *    predictions (boxes, class scores, mask coefficients).
-             * 2. `output1`: `(1, numMaskCoefs, maskH, maskW)` — prototype masks.
+             * Top-k classification probabilities for a single image.
              *
-             * `predict()` returns `Promise<SegmentationResults[]>` (length 1 for a
-             * single image), mirroring Ultralytics' API. The envelope exposes:
-             *
-             * - `boxes`: bulk numpy view (`xyxy`, `xywh`, `xyxyn`, `xywhn`, `cls`, `conf`).
-             * - `masks`: per-instance binary masks cropped to each box.
-             * - per-instance {@link SegmentationResult} via iteration.
-             *
-             * @example
-             * ```typescript
-             * const seg = await Segmenter.create("/models/yolov8n-seg.onnx");
-             * const r = (await seg.predict("/images/street.jpg"))[0];
-             * for (const inst of r) {
-             *   console.log(inst.cls, inst.conf, inst.box.xyxy);
-             * }
-             * ```
+             * Mirrors Ultralytics' `Probs` interface.
              */
-            export declare class Segmenter extends VisionTask {
-                private readonly _head;
-                private readonly _labels;
-                private readonly _names;
-                private readonly _inputSize;
-                private readonly _confThreshold;
-                private readonly _iouThreshold;
-                private readonly _maxDetections;
-                private readonly _maskThreshold;
-                private readonly _raiseOnEmpty;
-                private constructor();
-                private _pipelineCache;
+            export declare class Probs {
+                readonly data: Float32Array;
+                /** @param data `[numClasses]` per-class probabilities, indexed by class id. */
+                constructor(data: Float32Array);
+                /** Number of classes. */
+                get length(): number;
+                /** `[numClasses]` shape of the underlying vector. */
+                get shape(): readonly [number];
+                /** Index of the most probable class. */
+                get top1(): number;
+                /** Probability of the top-1 class. */
+                get top1conf(): number;
                 /**
-                 * Run the model once on a zero-filled tensor, paying one-time costs up front.
-                 *
-                 * The first inference of a session is not representative: WebGPU compiles its
-                 * shaders on it and the WASM backend faults in its arenas, which on a phone
-                 * can turn the first frame into seconds while every later frame is tens of
-                 * milliseconds. Calling this while a loading spinner is still up moves that
-                 * cost somewhere the user is already waiting.
+                 * Indices of the top-5 most probable classes, descending.
                  *
-                 * @param runs How many warm-up inferences to run. One is enough for WASM;
-                 *   WebGPU sometimes settles on the second.
+                 * The array is the memoised selection itself, not a copy — reading it twice
+                 * hands back the same object. Treat it as read-only: writing into it edits
+                 * what every later read of this `Probs` returns.
                  */
-                warmup(runs?: number): Promise<void>;
+                get top5(): Int32Array;
                 /**
-                 * The fused preprocessing pipeline, built on first use.
+                 * Probabilities of the top-5 classes, descending.
                  *
-                 * Lazily, because constructing it allocates canvases: a task built in an
-                 * environment without a canvas implementation stays constructible, and only
-                 * fails if it is actually asked to preprocess something.
+                 * Shares the memoised selection with {@link Probs.top5}, under the same
+                 * read-only caveat.
                  */
-                private get _pipeline();
-                /** Load the model and resolve labels. */
-                static create(model: ModelSource, options?: SegmenterOptions): Promise<Segmenter>;
-                /** The decoder family used to interpret the model's output. */
-                get head(): SegmenterHead;
-                /** Class labels indexed by class id. */
-                get labels(): readonly string[];
-                /** Class id → class name dict (matches Ultralytics' `model.names`). */
-                get names(): Readonly<Record<number, string>>;
+                get top5conf(): Float32Array;
+                private _cache;
                 /**
-                 * The `[width, height]` this task preprocesses to.
+                 * Memoised {@link Probs._topK}.
                  *
-                 * Resolved at creation time from the model's graph when it declares a static
-                 * input, so reading it back tells you the resolution inference really runs at
-                 * — not merely what was requested.
-                 */
-                get inputSize(): readonly [number, number];
-                /** Number of classes the model predicts. */
-                get numClasses(): number;
-                /** Alias for {@link predict} (parity with PyTorch `nn.Module.__call__`). */
-                call(image: ImageInput, options?: SegmenterPredictOptions): Promise<SegmentationResults[]>;
-                /** Run instance segmentation on a single image. */
-                predict(image: ImageInput, options?: SegmenterPredictOptions): Promise<SegmentationResults[]>;
-                private _preprocess;
-                private _splitOutputs;
-                private _buildResult;
-                private _buildBoxes;
-                private _buildMasks;
-            }
-
-            /**
-             * Decoder family for the segmentation head.
-             *
-             * - `"yolo-seg"`: YOLO instance-segmentation head with two outputs —
-             *   `[1, 4 + nc + nm, N]` per-anchor predictions plus `[1, nm, mh, mw]`
-             *   prototype masks. Covers YOLOv8-seg, v11-seg, v26-seg.
-             *
-             * The SDK does **not** auto-detect this — the caller is responsible for
-             * picking a head that matches their export.
-             */
-            export declare type SegmenterHead = "yolo-seg";
-
-            export declare interface SegmenterOptions extends OrtSessionOptions {
-                /**
-                 * Decoder family for the segmentation head. Default `"yolo-seg"` covers
-                 * YOLOv8-seg/v11-seg/v26-seg.
-                 */
-                readonly head?: SegmenterHead;
-                /** Class label spec — see {@link resolveLabels}. Defaults to the COCO 80-class preset. */
-                readonly labels?: LabelSpec;
-                /** Number of classes — used to validate the supplied labels. */
-                readonly numClasses?: number;
-                /**
-                 * Model input `[width, height]` in pixels for letterboxing.
+                 * `top5` and `top5conf` are separate getters over the same selection, so a
+                 * caller reading both would otherwise pay for it twice — once per frame, in
+                 * a camera loop. The probabilities a `Probs` was built from do not change,
+                 * so the result is computed once per `k` and kept.
                  *
-                 * Only used when the model's graph leaves its spatial axes dynamic: a graph
-                 * that declares a static size always wins, since that is the only shape ONNX
-                 * Runtime will accept. Defaults to `[640, 640]`.
-                 */
-                readonly inputSize?: readonly [number, number];
-                /** Default minimum class score to keep a candidate. */
-                readonly confThreshold?: number;
-                /** Default IoU threshold for non-maximum suppression. */
-                readonly iouThreshold?: number;
-                /** Maximum number of instances per image. */
-                readonly maxDetections?: number;
-                /**
-                 * If `true`, a run that finds nothing throws {@link NoDetectionsError}
-                 * instead of returning an empty envelope. Default `false`, because looking
-                 * and finding nothing is a successful inference. Turn it on when an empty
-                 * result means the surrounding pipeline should stop rather than carry on with
-                 * zero rows. Can be overridden per `predict` call.
-                 */
-                readonly raiseOnEmpty?: boolean;
-                /** Probability cutoff applied to soft masks. Defaults to `0.5`. */
-                readonly maskThreshold?: number;
-            }
-
-            export declare interface SegmenterPredictOptions {
-                readonly confThreshold?: number;
-                readonly iouThreshold?: number;
-                /**
-                 * If set, keep only instances whose `classId` is in this list.
-                 * Mirrors Ultralytics' `model.predict(img, classes=[0, 16])`.
+                 * @param k - How many classes to select.
+                 * @returns The cached selection for that `k`.
                  */
-                readonly classes?: readonly number[];
-                /** Override the constructor's `raiseOnEmpty` setting for this call. */
-                readonly raiseOnEmpty?: boolean;
-            }
-
-            /** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */
-            /**
-             * Classification head postprocessing — softmax + top-k.
-             */
-            /** Apply numerically-stable softmax to a 1-D vector of logits. */
-            export declare function softmax(logits: Float32Array | readonly number[]): Float32Array;
-
-            /**
-             * Read the spatial input size out of a declared NCHW shape.
-             *
-             * @param shape The declared shape of the model's image input.
-             * @returns `[width, height]` in pixels, or `null` when the shape is not 4D or
-             *   leaves either spatial axis dynamic — in which case the model accepts more
-             *   than one resolution and there is nothing to correct.
-             */
-            export declare function spatialInputSize(shape: DeclaredShape): readonly [number, number] | null;
-
-            /** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */
-            /**
-             * Per-stage timing for a single `predict()` call.
-             *
-             * Populates the `speed` field every `Results` envelope carries, mirroring
-             * Ultralytics' `results[0].speed`. All values are milliseconds measured with
-             * `performance.now()`.
-             */
-            /**
-             * Stage durations of one inference, in milliseconds.
-             *
-             * `preprocess`, `inference` and `postprocess` are the three keys Ultralytics
-             * reports, measured over the same boundaries. `load` is specific to this SDK:
-             * `predict()` accepts a URL, `Blob` or DOM element and decodes it internally,
-             * so the fetch/decode cost would otherwise be invisible — and on a cold cache
-             * it dominates everything else.
-             */
-            export declare interface Speed {
-                /** Fetching and decoding the input into an `RGBImage`. */
-                load: number;
-                /** Letterbox/resize, normalization and tensor packing. */
-                preprocess: number;
-                /** The ONNX Runtime forward pass. */
-                inference: number;
-                /** Decoding raw outputs into results (NMS, mask assembly, top-k). */
-                postprocess: number;
-            }
-
-            /**
-             * Accumulate stage durations while a `predict()` call runs.
-             *
-             * Each `stage()` call closes the previous stage: the elapsed time since the
-             * last boundary is attributed to the name given. This keeps the call sites
-             * free of paired start/stop bookkeeping and guarantees the four stages tile
-             * the whole call without gaps.
-             */
-            export declare class SpeedTimer {
-                private _last;
-                private readonly _speed;
-                constructor();
+                private _top;
                 /**
-                 * Attribute the time elapsed since the previous boundary to `stage`.
+                 * Select the `k` highest probabilities without ordering the rest.
                  *
-                 * @param stage Which stage just finished.
-                 */
-                stage(stage: keyof Speed): void;
-                /**
-                 * The accumulated durations.
+                 * A full sort to read five entries out of a thousand-class vector costs
+                 * O(n log n) plus an index array the size of the vector; keeping `k` slots
+                 * ordered by insertion and scanning once costs O(n·k) with no allocation
+                 * beyond the result. Measured on 1000 classes over 2000 iterations, 134.5 µs
+                 * against 1.5 µs for the same output.
                  *
-                 * @returns The `speed` object to hand to the `Results` envelope.
+                 * Ties keep the lower class index first, matching the stable sort this
+                 * replaced: a candidate only displaces an entry it is strictly greater
+                 * than. That is also what keeps this selection in step with the Python
+                 * SDK's `np.argsort(-data, kind="stable")`, where the sort is C and the
+                 * cost this avoids does not arise.
+                 *
+                 * @param k - How many classes to select.
+                 * @returns Indices and probabilities, descending by probability.
                  */
-                speed(): Speed;
+                private _topK;
             }
 
-            /**
-             * Transpose interleaved HWC data to planar CHW layout.
-             *
-             * @param hwc Source array of length `width * height * channels`.
-             */
-            export declare function toCHW(hwc: Float32Array, width: number, height: number, channels?: number): Float32Array;
+            /** Raised when a requested execution provider is not available. */
+            export declare class ProviderNotAvailableError extends OrtVisionError {
+            }
 
             /**
-             * Convert the SDK's HWC RGB image to an HWC BGR `Uint8Array` (OpenCV layout).
+             * One execution provider: its name, or ORT's config object for it.
              *
-             * Useful for round-tripping data to a Python OpenCV consumer.
+             * The object form carries provider options straight through to
+             * `InferenceSession.create` — `{ name: "webgpu", preferredLayout: "NHWC" }`,
+             * `{ name: "wasm" }` — which a bare name cannot express.
              */
-            export declare function toCv2(image: RGBImage): Uint8Array;
-
-            /** Convert a uint8 image to a `Float32Array` in `[0, 1]` (HWC layout preserved). */
-            export declare function toFloat32(image: RGBImage, scale?: number): Float32Array;
-
-            /** Wrap a Float32 buffer into an `ort.Tensor`. */
-            export declare function toFloat32Tensor(data: Float32Array, dims: readonly number[]): ort.Tensor;
+            export declare type ProviderSpec = string | {
+                readonly name: string;
+                readonly [option: string]: unknown;
+            };
 
             /**
-             * Return the top-k entries of a 1-D probability vector, sorted descending.
+             * Metadata key the Python SDK's `quantize_model` writes on an INT8 model.
              *
-             * @param k Number of entries to return; `null` returns all entries.
+             * Mirrored by `QUANTIZATION_KEY` in the Python SDK; both test suites pin the
+             * string. See {@link keepQuantizedOffWebGpu} for what a session does with it.
              */
-            export declare function topK(probabilities: Float32Array, k: number | null): TopKResult;
-
-            export declare interface TopKResult {
-                readonly indices: Int32Array;
-                readonly values: Float32Array;
-            }
+            export declare const QUANTIZATION_KEY = "ort_vision_sdk.quantization";
 
             /**
-             * Convert an HWC uint8 image to a CHW `Float32Array` scaled to `[0, 1]`.
+             * Read a pipeline spec out of a model's custom metadata.
              *
-             * Mirrors `torchvision.transforms.ToTensor()` semantics: HWC → CHW,
-             * `uint8 → float32 / 255`. Useful as input to YOLO-style detectors that
-             * don't require ImageNet normalization.
+             * Individual malformed entries fall back to the value a fusion would have used
+             * by default — a single bad float is not a reason to reject an otherwise
+             * loadable pipeline. A malformed resolution is fatal, because there is no safe
+             * default for one.
              *
-             * @returns CHW `Float32Array` of length `width * height * 3`.
+             * @param metadata A model's custom metadata map, as read by
+             *   {@link readModelMetadata}.
+             * @returns The decoded spec, or `null` when the model is not a fused pipeline —
+             *   it carries no `ovs.kind` entry, or one naming a pipeline kind this version
+             *   does not know how to drive.
              */
-            export declare function toTensor(image: RGBImage): Float32Array;
+            export declare function readFusionSpec(metadata: Readonly<Record<string, string>> | undefined): FusionSpec | null;
 
             /**
-             * Acquire a `MediaStream` via `getUserMedia`, attach it to a `<video>` element,
-             * and expose status/error so the page can render permission and error states.
-             * The stream is automatically released on unmount or retry.
-             *
-             * Defaults to the rear ("environment") camera; desktops fall back to whatever
-             * single camera they expose. Pass `options.constraints` to override, or
-             * `options.enabled: false` to render the surface without prompting for the camera
-             * at all.
+             * Read the element type each graph input declares.
              *
-             * Implementation notes:
-             * - Cleanup detaches the stream from a *snapshotted* video node, so it releases
-             *   the same element it attached to even if the page remounts the `<video>`.
-             * - When `getUserMedia` is missing, an insecure context is the usual cause, so
-             *   the hook prefers that (actionable) error; otherwise it reports `unsupported`.
-             * - `video.play()` rejections are swallowed: autoplay may be blocked, but the
-             *   user gesture that opened the camera usually counts and playback resumes on
-             *   the next interaction.
+             * `onnxruntime-web` does not expose this. `session.inputMetadata` is
+             * `undefined` on 1.20.1 — the same version where `declaredShapesFrom` comes
+             * back empty — so the declared types have to come from the file, which the SDK
+             * already downloads and walks for {@link readModelMetadata}. Same bytes, one
+             * more pass, no extra request.
              *
-             * @param options - optional configuration (see {@link UseCameraStreamOptions}).
-             * @returns The stream status, classified error, a `videoRef` to attach, the live
-             *   `stream` for whatever needs the track itself, and a `retry()` to re-attempt
-             *   acquisition.
+             * @param model The `.onnx` file contents.
+             * @returns Input name → `TensorProto.DataType` value. An empty object when the
+             *   file carries no readable graph, which every caller treats as "assume
+             *   float32" — the behaviour before any of this existed.
              */
-            export declare function useCameraStream(options?: UseCameraStreamOptions): UseCameraStreamApi;
-
-            /** Value returned by {@link useCameraStream}. */
-            export declare interface UseCameraStreamApi {
-                /** Current lifecycle status. */
-                status: CameraStreamStatus;
-                /** The classified error, or `null` while not in the `error` status. */
-                error: CameraStreamError | null;
-                /** Attach to a `<video ref={…} />`. The stream is wired to it once ready. */
-                videoRef: RefObject<HTMLVideoElement | null>;
-                /**
-                 * The live stream, or `null`.
-                 *
-                 * Exposed for the things that need the **track** rather than the picture — the LED
-                 * torch (`useTorch`), the real frame size from `getSettings()`, recording it with
-                 * `useVideoRecorder`. Do not stop it yourself: the hook owns its lifetime and
-                 * releases it on unmount and on `retry()`.
-                 */
-                stream: MediaStream | null;
-                /** Manually re-attempt after an error (e.g. the user changed permissions). */
-                retry: () => void;
-            }
-
-            /** Options for {@link useCameraStream}. */
-            export declare interface UseCameraStreamOptions {
-                /**
-                 * Constraints passed to `getUserMedia`. Defaults to the rear
-                 * ("environment") camera at Full-HD ideal resolution with audio off.
-                 * Read when the stream (re)starts — change it and call `retry()` to apply.
-                 */
-                constraints?: MediaStreamConstraints;
-                /**
-                 * Hold off acquiring the camera until this is `true`. Default `true`.
-                 *
-                 * The point is to be able to *not* prompt. A permission prompt costs the user a
-                 * decision and, if they refuse, costs the app the feature permanently — so a
-                 * surface that already knows it cannot do its job (a barcode scanner in a browser
-                 * with no decoder) must not open the camera to then say so. Flipping this to `false`
-                 * also releases a stream that is already live.
-                 */
-                enabled?: boolean;
-            }
+            export declare function readModelInputTypes(model: Uint8Array | ArrayBufferLike): Readonly<Record<string, number>>;
 
+            /** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */
             /**
-             * Sample mean luminance from a `<video>` source on a `requestAnimationFrame`
-             * loop and expose the rolling value. Sampling is throttled by `intervalMs` and
-             * paused whenever `enabled` is `false` or the video is not ready yet
-             * (`readyState < 2` or `videoWidth === 0`).
+             * Read the metadata an exporter baked into a `.onnx` file.
              *
-             * One offscreen canvas is reused across frames to avoid GC pressure. Designed
-             * to feed a live brightness bar / border color on a camera page.
+             * `onnxruntime-web` exposes input/output metadata but **not** the model's
+             * custom metadata map, which is where Ultralytics writes `names`, `task` and
+             * `imgsz`. The Python SDK gets it for free from
+             * `InferenceSession.get_modelmeta().custom_metadata_map`; in the browser the
+             * only way to the same information is to read it out of the file, so this
+             * module walks just enough of the ModelProto wire format to collect
+             * `metadata_props`.
              *
-             * @param videoRef - ref to the `<video>` element to sample.
-             * @param options - optional configuration (see {@link UseLiveLuminanceOptions}).
-             * @returns The rolling mean luminance in `0..255` (`0` until the first sample).
+             * It never throws and never allocates unbounded: a truncated, hostile or
+             * simply unexpected file yields an empty map, and every caller treats that as
+             * "the model says nothing", falling back to what it was given.
              */
-            export declare function useLiveLuminance(videoRef: RefObject<HTMLVideoElement | null>, { enabled, intervalMs }?: UseLiveLuminanceOptions): number;
-
-            /** Options for {@link useLiveLuminance}. */
-            export declare interface UseLiveLuminanceOptions {
-                /** When `false` the loop is paused (e.g. while a capture is in flight). Default: `true`. */
-                enabled?: boolean;
-                /** Throttle measurements in milliseconds. Default: `160` (~6 fps), plenty for UX. */
-                intervalMs?: number;
-            }
-
-            export declare const VERSION: string;
-
-            export declare abstract class VisionTask {
-                protected readonly _session: OrtSession;
-                protected constructor(_session: OrtSession);
-                /** The underlying {@link OrtSession} used to run inference. */
-                get session(): OrtSession;
-            }
-
             /**
-             * Write an RGBA buffer as normalized planar float32.
-             *
-             * Shared by {@link ResizePipeline} and exported for a custom pipeline that
-             * already holds pixels and wants the SDK's exact arithmetic.
+             * Collect a model's custom metadata map straight out of its bytes.
              *
-             * The expression is `(value / 255 - mean) / std`, evaluated in that order on
-             * purpose: folding it into a single multiply-add (`value * k + b`) computes the
-             * same quantity but rounds differently, and the tasks' output is asserted to be
-             * bit-identical to the composable `normalize` → `toCHW` path.
-             *
-             * @param rgba Source pixels, 4 bytes per pixel, `width * height` long.
-             * @param width Image width in pixels.
-             * @param height Image height in pixels.
-             * @param mean Per-channel RGB mean, already in `[0, 1]`.
-             * @param std Per-channel RGB standard deviation.
-             * @param out Destination buffer, `3 * width * height` long.
-             * @param stride Bytes per source pixel: 4 for canvas RGBA, 3 for packed RGB.
+             * @param model The `.onnx` file contents.
+             * @returns Key/value metadata — `names`, `task`, `imgsz`, ... for an
+             *   Ultralytics export — or an empty object when the file carries none or
+             *   cannot be walked.
              */
-            export declare function writePlanarFloat32(rgba: Uint8ClampedArray | Uint8Array, width: number, height: number, mean: readonly [number, number, number], std: readonly [number, number, number], out: Float32Array, stride?: number): void;
+            export declare function readModelMetadata(model: Uint8Array | ArrayBufferLike): Readonly<Record<string, string>>;
 
             /**
-             * Build a zero-filled CHW tensor payload for a warm-up run.
+             * Turn an empty result into an error, when the caller asked for that.
              *
-             * @param width Model input width in pixels.
-             * @param height Model input height in pixels.
-             */
-            export declare function zeroTensorData(width: number, height: number): Float32Array;
-
-            export { }
+             * Shared by every task that can come back with nothing — {@link Detector},
+             * {@link Segmenter} and {@link DetectClassify} — so the three agree on when
+             * they throw and on what the message says. The message names the two settings
+             * that decide the outcome, because "no detections" on its own leaves the reader
+             * unable to tell a blank image from a threshold set too high.
+             *
+             * @param count How many detections survived every filter.
+             * @param options The flag for this call, the threshold actually applied (after
+             *   any per-call override), the class allowlist if one narrowed the search, and
+             *   the source path when the input was one.
+             * @throws {@link NoDetectionsError} when the flag is set and `count` is zero.
+                 */
+             export declare function requireDetections(count: number, options: {
+                 readonly raiseOnEmpty: boolean;
+                 readonly confThreshold: number;
+                 readonly classes: readonly number[] | undefined;
+                 readonly path: string | null;
+             }): void;
+
+             /** Resize an image to `(targetWidth, targetHeight)` using high-quality canvas resampling. */
+             export declare function resize(image: RGBImage, targetWidth: number, targetHeight: number): RGBImage;
+
+             /**
+              * Reusable stretch-resize → normalized tensor pipeline for one target size.
+              *
+              * The classification counterpart of {@link LetterboxPipeline}. A classifier
+              * stretches to the model's square input instead of letterboxing into it — no
+              * padding, no scale to invert later, because nothing is mapped back onto the
+              * source image afterwards. That difference is why it cannot simply reuse the
+              * letterbox path.
+              *
+              * What it does share is the technique. The composable route
+              * (`resize` → `normalize` → `toCHW`) allocates an `RGBImage` and two
+              * `Float32Array`s and walks each end to end on every call: about 1.4 MB of
+              * fresh garbage per 224×224 `predict()`, produced at the exact moment a phone
+              * near its memory ceiling can least afford it. Here one `drawImage` resizes,
+              * and one loop reads the resulting RGBA and writes normalized planar float32
+              * into a buffer held across calls.
+              *
+              * Create one per task, not per frame.
+              */
+             export declare class ResizePipeline {
+                 private readonly _targetWidth;
+                 private readonly _targetHeight;
+                 private readonly _mean;
+                 private readonly _std;
+                 private readonly _buffer;
+                 private _target;
+                 private _targetContext;
+                 private _source;
+                 private _sourceContext;
+                 /**
+                  * @param targetWidth Model input width in pixels.
+                  * @param targetHeight Model input height in pixels.
+                  * @param mean Per-channel RGB mean in `[0, 1]`. Defaults to no shift.
+                  * @param std Per-channel RGB standard deviation. Defaults to no scaling.
+                  */
+                 constructor(targetWidth: number, targetHeight: number, mean?: readonly [number, number, number], std?: readonly [number, number, number]);
+                 /** The `[width, height]` this pipeline resizes into. */
+                 get targetSize(): readonly [number, number];
+                 /**
+                  * Resize an image to the target size and write it as normalized planar float32.
+                  *
+                  * An image that already arrives at the target size skips the canvas entirely
+                  * and is read straight out of its packed RGB — which is both faster and what
+                  * keeps the result identical to `resize()`, whose own fast path returns the
+                  * input untouched.
+                  *
+                  * Buffer reuse follows {@link ReusableBuffer}: held across calls, replaced when
+                  * a consumer detached it by transferring the tensor.
+                  *
+                  * @param image Source image in the SDK's canonical HWC RGB layout.
+                  * @param canvas Optional opaque drawable holding exactly `image`'s pixels —
+                  *   see {@link LetterboxPipeline.run}. Ignored on the same-size fast path,
+                  *   which never touches a canvas.
+                  */
+                 run(image: RGBImage, canvas?: CanvasImageSource | null): FusedResizeResult;
+                 /**
+                  * Mark the reusable buffer free again.
+                  *
+                  * Call it once the tensor built from a {@link run} result has been handed to
+                  * ONNX Runtime and the run has resolved — after that the values are inside
+                  * the WASM heap and the buffer can be overwritten.
+                  *
+                  * Pass the result being released when several runs can be outstanding at
+                  * once. A result that got a fresh allocation (`reused: false`) holds nothing
+                  * of the pipeline's, so releasing it is a no-op; without that check, the
+                  * caller finishing with a fresh buffer would free the shared one while
+                  * another caller still had its frame in it. Called without an argument it
+                  * frees the shared buffer unconditionally, as before.
+                  *
+                  * @param result The {@link run} result being released.
+                  */
+                 release(result?: {
+                     readonly reused: boolean;
+                 }): void;
+                 /**
+                  * Build the target canvas on first use.
+                  *
+                  * Lazily, so a pipeline constructed where no canvas implementation exists
+                  * (a Node test, a worker without OffscreenCanvas) only fails if it is asked
+                  * to resize something.
+                  */
+                 private _ensureTarget;
+                 /**
+                  * Paint an image onto the scratch source canvas and return that canvas.
+                  *
+                  * @param image Source image in the SDK's canonical HWC RGB layout.
+                  */
+                 private _paintSource;
+             }
+
+             /**
+              * Resize an image into normalized planar float32 without keeping any state.
+              *
+              * The allocation-free path is {@link ResizePipeline}; this is the one-shot
+              * form, for a caller who wants the fused behaviour without owning a pipeline.
+              *
+              * @param image Source image in the SDK's canonical HWC RGB layout.
+              * @param targetWidth Model input width in pixels.
+              * @param targetHeight Model input height in pixels.
+              * @param mean Per-channel RGB mean in `[0, 1]`. Defaults to no shift.
+              * @param std Per-channel RGB standard deviation. Defaults to no scaling.
+              */
+             export declare function resizeToTensorData(image: RGBImage, targetWidth: number, targetHeight: number, mean?: readonly [number, number, number], std?: readonly [number, number, number]): FusedResizeResult;
+
+             /** What {@link resolveNormalization} settled on. */
+             export declare interface ResolvedNormalization {
+                 /** The preset name, or `"custom"` when the caller supplied the values. */
+                 readonly name: string;
+                 /** Per-channel mean to subtract. */
+                 readonly mean: readonly [number, number, number];
+                 /** Per-channel deviation to divide by. */
+                 readonly std: readonly [number, number, number];
+             }
+
+             /**
+              * Decide the input size a task will preprocess to.
+              *
+              * Precedence is graph → caller → fallback. The graph wins over an explicit
+              * `inputSize` because a static shape is not a preference, it is what ORT will
+              * accept: honoring the caller there would only turn a fixable mismatch into a
+              * failed run. A disagreement is a configuration bug in the caller, so it is
+              * reported through `console.warn` instead of being swallowed.
+              *
+              * @param options Graph shape, requested size and per-task fallback.
+              * @returns The `[width, height]` to preprocess to.
+              */
+             export declare function resolveInputSize(options: ResolveInputSizeOptions): readonly [number, number];
+
+             export declare interface ResolveInputSizeOptions {
+                 /** Declared shape of the model's image input, from {@link declaredShapesFrom}. */
+                 readonly graphShape?: DeclaredShape;
+                 /** Size the caller asked for, if any. */
+                 readonly requested?: readonly [number, number];
+                 /** Size to use when neither the graph nor the caller pins one. */
+                 readonly fallback: readonly [number, number];
+             }
+
+             export declare function resolveLabels(spec: LabelSpec, options?: ResolveLabelsOptions): readonly string[];
+
+             export declare interface ResolveLabelsOptions {
+                 /**
+                  * Expected number of classes.
+                  *
+                  * - When `spec` is `null`/`undefined`, this is required to auto-generate names.
+                  * - When `spec` is provided, it validates that the resolved length matches.
+                  */
+                 readonly numClasses?: number;
+             }
+
+             /**
+              * Settle which `mean`/`std` to apply, and what to call the choice.
+              *
+              * Explicit `mean`/`std` always win — they are the escape hatch for a model whose
+              * preprocessing neither preset describes. Anything they leave open falls back to
+              * the preset, so passing only a `mean` does not silently reset the deviation
+              * to 1.
+              *
+              * Warns (via `console.warn`) when the model is an Ultralytics export and the
+              * supplied values are not the identity it was trained with. Nothing fails in
+              * that case: the prediction has the right shape and is simply less accurate,
+              * which is exactly why it is worth saying out loud.
+              *
+              * @param metadata The model's custom metadata map, read to detect the family.
+              * @param options The preset asked for, plus any explicit `mean`/`std`.
+              * @throws {RangeError} If `normalization` is not a known preset, or names one
+              *   while `mean`/`std` are also supplied — two answers to the same question.
+              */
+             export declare function resolveNormalization(metadata: Readonly<Record<string, string>>, options?: {
+                 readonly normalization?: Normalization;
+                 readonly mean?: readonly [number, number, number];
+                 readonly std?: readonly [number, number, number];
+             }): ResolvedNormalization;
+
+             /**
+              * Resolve the execution providers to pass to `InferenceSession.create`.
+              *
+              * @param requested Explicit provider list in preference order, as names or
+              *   config objects; `undefined` or empty returns the default.
+              */
+             export declare function resolveProviders<T extends ProviderSpec = string>(requested?: readonly T[]): (T | string)[];
+
+             /** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */
+             /**
+              * Public output types returned by the SDK's vision tasks.
+              *
+              * These types form the contract between the SDK and its callers. They mirror
+              * the Python `ort-vision-sdk` output dataclasses 1-to-1.
+              *
+              * Naming is intentionally compatible with the Ultralytics / torchvision idiom
+              * (`cls`, `conf`, `box`, `xyxy`, `xywh`, normalized variants) so code ported
+              * from those projects keeps working with minimal edits. The original verbose
+              * names (`classId`, `className`, `confidence`, `bbox`) are still populated for
+              * backwards compatibility.
+              */
+             /**
+              * HWC RGB uint8 image — the canonical image format used across the SDK.
+              *
+              * `data.length` must equal `width * height * 3`. The buffer is laid out row
+              * by row, top-to-bottom, with each pixel as `[R, G, B]`.
+              *
+              * The pixels can also be produced on first read — see {@link RGBImage.deferred}.
+              * Reading `data` is the same either way.
+              */
+             export declare class RGBImage {
+                 readonly width: number;
+                 readonly height: number;
+                 private _data;
+                 private _materialize;
+                 constructor(data: Uint8Array, width: number, height: number);
+                 /**
+                  * An image whose pixels are computed the first time `data` is read.
+                  *
+                  * Used by the decoder for frames it can hand to preprocessing without
+                  * reading back: a 1080p `getImageData` plus the RGBA→RGB copy is most of
+                  * the `load` stage (9.4 ms vs 1.9 ms for the GPU-side copy, measured in
+                  * Chromium), and a camera loop that only reads boxes never needs it.
+                  *
+                  * @param width Width in pixels.
+                  * @param height Height in pixels.
+                  * @param materialize Produces the `width * height * 3` buffer; called at most
+                  *   once, and must keep returning the pixels of the moment the image was
+                  *   made — snapshot whatever it reads from.
+                  * @returns The image. Built without the constructor, which would need the
+                  *   very buffer this defers.
+                  */
+                 static deferred(width: number, height: number, materialize: () => Uint8Array): RGBImage;
+                 /**
+                  * The HWC RGB pixels, materialized on first read for a deferred image.
+                  *
+                  * @throws {@link ImageLoadError} if a deferred image's buffer has the wrong length.
+                      */
+                  get data(): Uint8Array;
+                  /**
+                   * Validate a buffer's length against the image size.
+                   *
+                   * @param data The pixels.
+                   * @param width Width in pixels.
+                   * @param height Height in pixels.
+                   * @throws {@link ImageLoadError} if `data.length !== width * height * 3`.
+                       */
+                   private static _check;
+                  }
+
+                  /**
+                   * Single segmented instance produced by an instance-segmentation model.
+                   *
+                   * Mirrors {@link DetectionResult} and adds the per-instance binary mask
+                   * plus a "ready-to-display" background-removed crop.
+                   */
+                  export declare interface SegmentationResult {
+                      readonly classId: number;
+                      readonly className: string;
+                      readonly confidence: number;
+                      readonly bbox: BoundingBox;
+                      /** Alias for `classId` (Ultralytics-style). */
+                      readonly cls: number;
+                      /** Alias for `className`. */
+                      readonly name: string;
+                      /** Alias for `confidence` (Ultralytics-style). */
+                      readonly conf: number;
+                      /** Alias for `bbox` (Ultralytics-style). */
+                      readonly box: BoundingBox;
+                      /**
+                       * Binary mask cropped to `bbox`. Values are `0` (background) or `255`
+                       * (foreground). Empty boxes yield a zero-sized `Mask`.
+                       */
+                      readonly mask: Mask;
+                      /**
+                       * The original image cropped to `bbox` with background pixels (where
+                       * `mask.data[i] === 0`) zeroed out. Empty boxes yield a zero-sized
+                       * `RGBImage`.
+                       */
+                      readonly segmentedImage: RGBImage;
+                  }
+
+                  /**
+                   * Per-image instance-segmentation envelope (Ultralytics-style `Results`).
+                   *
+                   * Iterating yields per-instance {@link SegmentationResult} entries. `boxes`
+                   * and `masks` mirror Ultralytics' bulk-array views.
+                   */
+                  export declare class SegmentationResults implements Iterable<SegmentationResult> {
+                      readonly boxes: Boxes;
+                      readonly masks: Masks;
+                      readonly detections: readonly SegmentationResult[];
+                      readonly names: Readonly<Record<number, string>>;
+                      readonly origImg: RGBImage;
+                      readonly origShape: readonly [number, number];
+                      readonly path: string | null;
+                      readonly speed: Readonly<Speed>;
+                      constructor(boxes: Boxes, masks: Masks, detections: readonly SegmentationResult[], names: Readonly<Record<number, string>>, origImg: RGBImage, origShape: readonly [number, number], path?: string | null, speed?: Readonly<Speed>);
+                      /** Number of surviving instances. */
+                      get length(): number;
+                      /** Index into the per-instance results. */
+                      get(index: number): SegmentationResult | undefined;
+                      [Symbol.iterator](): Iterator<SegmentationResult>;
+                  }
+
+                  /**
+                   * Instance segmenter for YOLO seg ONNX models (v8-seg / v11-seg / ...).
+                   *
+                   * The model is expected to expose two outputs:
+                   *
+                   * 1. `output0`: `(1, 4 + numClasses + numMaskCoefs, numAnchors)` — per-anchor
+                   *    predictions (boxes, class scores, mask coefficients).
+                   * 2. `output1`: `(1, numMaskCoefs, maskH, maskW)` — prototype masks.
+                   *
+                   * `predict()` returns `Promise<SegmentationResults[]>` (length 1 for a
+                   * single image), mirroring Ultralytics' API. The envelope exposes:
+                   *
+                   * - `boxes`: bulk numpy view (`xyxy`, `xywh`, `xyxyn`, `xywhn`, `cls`, `conf`).
+                   * - `masks`: per-instance binary masks cropped to each box.
+                   * - per-instance {@link SegmentationResult} via iteration.
+                   *
+                   * @example
+                   * ```typescript
+                   * const seg = await Segmenter.create("/models/yolov8n-seg.onnx");
+                   * const r = (await seg.predict("/images/street.jpg"))[0];
+                   * for (const inst of r) {
+                   *   console.log(inst.cls, inst.conf, inst.box.xyxy);
+                   * }
+                   * ```
+                   */
+                  export declare class Segmenter extends VisionTask {
+                      private readonly _head;
+                      private readonly _labels;
+                      private readonly _names;
+                      private readonly _inputSize;
+                      private readonly _confThreshold;
+                      private readonly _iouThreshold;
+                      private readonly _maxDetections;
+                      private readonly _maskThreshold;
+                      private readonly _raiseOnEmpty;
+                      private constructor();
+                      private _pipelineCache;
+                      /**
+                       * Run the model once on a zero-filled tensor, paying one-time costs up front.
+                       *
+                       * The first inference of a session is not representative: WebGPU compiles its
+                       * shaders on it and the WASM backend faults in its arenas, which on a phone
+                       * can turn the first frame into seconds while every later frame is tens of
+                       * milliseconds. Calling this while a loading spinner is still up moves that
+                       * cost somewhere the user is already waiting.
+                       *
+                       * @param runs How many warm-up inferences to run. One is enough for WASM;
+                       *   WebGPU sometimes settles on the second.
+                       */
+                      warmup(runs?: number): Promise<void>;
+                      /**
+                       * The fused preprocessing pipeline, built on first use.
+                       *
+                       * Lazily, because constructing it allocates canvases: a task built in an
+                       * environment without a canvas implementation stays constructible, and only
+                       * fails if it is actually asked to preprocess something.
+                       */
+                      private get _pipeline();
+                      /** Load the model and resolve labels. */
+                      static create(model: ModelSource, options?: SegmenterOptions): Promise<Segmenter>;
+                      /** The decoder family used to interpret the model's output. */
+                      get head(): SegmenterHead;
+                      /** Class labels indexed by class id. */
+                      get labels(): readonly string[];
+                      /** Class id → class name dict (matches Ultralytics' `model.names`). */
+                      get names(): Readonly<Record<number, string>>;
+                      /**
+                       * The `[width, height]` this task preprocesses to.
+                       *
+                       * Resolved at creation time from the model's graph when it declares a static
+                       * input, so reading it back tells you the resolution inference really runs at
+                       * — not merely what was requested.
+                       */
+                      get inputSize(): readonly [number, number];
+                      /** Number of classes the model predicts. */
+                      get numClasses(): number;
+                      /** Alias for {@link predict} (parity with PyTorch `nn.Module.__call__`). */
+                      call(image: ImageInput, options?: SegmenterPredictOptions): Promise<SegmentationResults[]>;
+                      /** Run instance segmentation on a single image. */
+                      predict(image: ImageInput, options?: SegmenterPredictOptions): Promise<SegmentationResults[]>;
+                      /**
+                       * Letterbox and pack the image into the tensor the model expects.
+                       *
+                       * @param image The decoded input.
+                       * @param canvas The opaque canvas it was decoded on, when there is one — see
+                       *   {@link LetterboxPipeline.run}.
+                       */
+                      private _preprocess;
+                      private _splitOutputs;
+                      /**
+                       * Assemble one instance.
+                       *
+                       * The mask is trimmed to the part of the box inside the frame up front — it
+                       * is small and every caller reads it. `segmentedImage`, a masked copy of the
+                       * frame's pixels, is built on first read when the SDK owns those pixels and
+                       * up front otherwise, for the reason {@link Detector} gives for its crops.
+                       *
+                       * @param original The decoded input.
+                       * @param bbox Box in original-image coordinates.
+                       * @param classId Predicted class.
+                       * @param confidence Detection score.
+                       * @param mask Binary mask shaped to `bbox`.
+                       * @param lazy Whether `segmentedImage` may be deferred.
+                       */
+                      private _buildResult;
+                      private _buildBoxes;
+                      private _buildMasks;
+                  }
+
+                  /**
+                   * Decoder family for the segmentation head.
+                   *
+                   * - `"yolo-seg"`: YOLO instance-segmentation head with two outputs —
+                   *   `[1, 4 + nc + nm, N]` per-anchor predictions plus `[1, nm, mh, mw]`
+                   *   prototype masks. Covers YOLOv8-seg, v11-seg, v26-seg.
+                   *
+                   * The SDK does **not** auto-detect this — the caller is responsible for
+                   * picking a head that matches their export.
+                   */
+                  export declare type SegmenterHead = "yolo-seg";
+
+                  export declare interface SegmenterOptions extends OrtSessionOptions {
+                      /**
+                       * Decoder family for the segmentation head. Default `"yolo-seg"` covers
+                       * YOLOv8-seg/v11-seg/v26-seg.
+                       */
+                      readonly head?: SegmenterHead;
+                      /** Class label spec — see {@link resolveLabels}. Defaults to the COCO 80-class preset. */
+                      readonly labels?: LabelSpec;
+                      /** Number of classes — used to validate the supplied labels. */
+                      readonly numClasses?: number;
+                      /**
+                       * Model input `[width, height]` in pixels for letterboxing.
+                       *
+                       * Only used when the model's graph leaves its spatial axes dynamic: a graph
+                       * that declares a static size always wins, since that is the only shape ONNX
+                       * Runtime will accept. Defaults to `[640, 640]`.
+                       */
+                      readonly inputSize?: readonly [number, number];
+                      /** Default minimum class score to keep a candidate. */
+                      readonly confThreshold?: number;
+                      /** Default IoU threshold for non-maximum suppression. */
+                      readonly iouThreshold?: number;
+                      /** Maximum number of instances per image. */
+                      readonly maxDetections?: number;
+                      /**
+                       * If `true`, a run that finds nothing throws {@link NoDetectionsError}
+                       * instead of returning an empty envelope. Default `false`, because looking
+                       * and finding nothing is a successful inference. Turn it on when an empty
+                       * result means the surrounding pipeline should stop rather than carry on with
+                       * zero rows. Can be overridden per `predict` call.
+                       */
+                      readonly raiseOnEmpty?: boolean;
+                      /** Probability cutoff applied to soft masks. Defaults to `0.5`. */
+                      readonly maskThreshold?: number;
+                  }
+
+                  export declare interface SegmenterPredictOptions {
+                      readonly confThreshold?: number;
+                      readonly iouThreshold?: number;
+                      /**
+                       * If set, keep only instances whose `classId` is in this list.
+                       * Mirrors Ultralytics' `model.predict(img, classes=[0, 16])`.
+                       */
+                      readonly classes?: readonly number[];
+                      /** Override the constructor's `raiseOnEmpty` setting for this call. */
+                      readonly raiseOnEmpty?: boolean;
+                  }
+
+                  /** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */
+                  /**
+                   * Classification head postprocessing — softmax + top-k.
+                   */
+                  /** Apply numerically-stable softmax to a 1-D vector of logits. */
+                  export declare function softmax(logits: Float32Array | readonly number[]): Float32Array;
+
+                  /**
+                   * Read the spatial input size out of a declared NCHW shape.
+                   *
+                   * @param shape The declared shape of the model's image input.
+                   * @returns `[width, height]` in pixels, or `null` when the shape is not 4D or
+                   *   leaves either spatial axis dynamic — in which case the model accepts more
+                   *   than one resolution and there is nothing to correct.
+                   */
+                  export declare function spatialInputSize(shape: DeclaredShape): readonly [number, number] | null;
+
+                  /** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */
+                  /**
+                   * Per-stage timing for a single `predict()` call.
+                   *
+                   * Populates the `speed` field every `Results` envelope carries, mirroring
+                   * Ultralytics' `results[0].speed`. All values are milliseconds measured with
+                   * `performance.now()`.
+                   */
+                  /**
+                   * Stage durations of one inference, in milliseconds.
+                   *
+                   * `preprocess`, `inference` and `postprocess` are the three keys Ultralytics
+                   * reports, measured over the same boundaries. `load` is specific to this SDK:
+                   * `predict()` accepts a URL, `Blob` or DOM element and decodes it internally,
+                   * so the fetch/decode cost would otherwise be invisible — and on a cold cache
+                   * it dominates everything else.
+                   */
+                  export declare interface Speed {
+                      /** Fetching and decoding the input into an `RGBImage`. */
+                      load: number;
+                      /** Letterbox/resize, normalization and tensor packing. */
+                      preprocess: number;
+                      /** The ONNX Runtime forward pass. */
+                      inference: number;
+                      /** Decoding raw outputs into results (NMS, mask assembly, top-k). */
+                      postprocess: number;
+                  }
+
+                  /**
+                   * Accumulate stage durations while a `predict()` call runs.
+                   *
+                   * Each `stage()` call closes the previous stage: the elapsed time since the
+                   * last boundary is attributed to the name given. This keeps the call sites
+                   * free of paired start/stop bookkeeping and guarantees the four stages tile
+                   * the whole call without gaps.
+                   */
+                  export declare class SpeedTimer {
+                      private _last;
+                      private readonly _speed;
+                      constructor();
+                      /**
+                       * Attribute the time elapsed since the previous boundary to `stage`.
+                       *
+                       * @param stage Which stage just finished.
+                       */
+                      stage(stage: keyof Speed): void;
+                      /**
+                       * The accumulated durations.
+                       *
+                       * @returns The `speed` object to hand to the `Results` envelope.
+                       */
+                      speed(): Speed;
+                  }
+
+                  /**
+                   * Name the tensor type an ONNX element type maps to.
+                   *
+                   * @param elemType A `TensorProto.DataType` value read off the graph.
+                   * @returns The ORT tensor type name, or `"float32"` for anything unrecognised —
+                   *   which is what every task produces anyway, so an unknown type surfaces as
+                   *   ORT's own type error against the real graph rather than as a lookup miss.
+                   */
+                  export declare function tensorTypeFor(elemType: number | undefined): string;
+
+                  /**
+                   * Transpose interleaved HWC data to planar CHW layout.
+                   *
+                   * @param hwc Source array of length `width * height * channels`.
+                   */
+                  export declare function toCHW(hwc: Float32Array, width: number, height: number, channels?: number): Float32Array;
+
+                  /**
+                   * Convert the SDK's HWC RGB image to an HWC BGR `Uint8Array` (OpenCV layout).
+                   *
+                   * Useful for round-tripping data to a Python OpenCV consumer.
+                   */
+                  export declare function toCv2(image: RGBImage): Uint8Array;
+
+                  /** Convert a uint8 image to a `Float32Array` in `[0, 1]` (HWC layout preserved). */
+                  export declare function toFloat32(image: RGBImage, scale?: number): Float32Array;
+
+                  /** Wrap a Float32 buffer into an `ort.Tensor`. */
+                  export declare function toFloat32Tensor(data: Float32Array, dims: readonly number[]): ort.Tensor;
+
+                  /**
+                   * Return the top-k entries of a 1-D probability vector, sorted descending.
+                   *
+                   * @param k Number of entries to return; `null` returns all entries.
+                   */
+                  export declare function topK(probabilities: Float32Array, k: number | null): TopKResult;
+
+                  export declare interface TopKResult {
+                      readonly indices: Int32Array;
+                      readonly values: Float32Array;
+                  }
+
+                  /**
+                   * Convert an HWC uint8 image to a CHW `Float32Array` scaled to `[0, 1]`.
+                   *
+                   * Mirrors `torchvision.transforms.ToTensor()` semantics: HWC → CHW,
+                   * `uint8 → float32 / 255`. Useful as input to YOLO-style detectors that
+                   * don't require ImageNet normalization.
+                   *
+                   * @returns CHW `Float32Array` of length `width * height * 3`.
+                   */
+                  export declare function toTensor(image: RGBImage): Float32Array;
+
+                  /**
+                   * Acquire a `MediaStream` via `getUserMedia`, attach it to a `<video>` element,
+                   * and expose status/error so the page can render permission and error states.
+                   * The stream is automatically released on unmount or retry.
+                   *
+                   * Defaults to the rear ("environment") camera; desktops fall back to whatever
+                   * single camera they expose. Pass `options.constraints` to override, or
+                   * `options.enabled: false` to render the surface without prompting for the camera
+                   * at all.
+                   *
+                   * Implementation notes:
+                   * - Cleanup detaches the stream from a *snapshotted* video node, so it releases
+                   *   the same element it attached to even if the page remounts the `<video>`.
+                   * - When `getUserMedia` is missing, an insecure context is the usual cause, so
+                   *   the hook prefers that (actionable) error; otherwise it reports `unsupported`.
+                   * - `video.play()` rejections are swallowed: autoplay may be blocked, but the
+                   *   user gesture that opened the camera usually counts and playback resumes on
+                   *   the next interaction.
+                   *
+                   * @param options - optional configuration (see {@link UseCameraStreamOptions}).
+                   * @returns The stream status, classified error, a `videoRef` to attach, the live
+                   *   `stream` for whatever needs the track itself, and a `retry()` to re-attempt
+                   *   acquisition.
+                   */
+                  export declare function useCameraStream(options?: UseCameraStreamOptions): UseCameraStreamApi;
+
+                  /** Value returned by {@link useCameraStream}. */
+                  export declare interface UseCameraStreamApi {
+                      /** Current lifecycle status. */
+                      status: CameraStreamStatus;
+                      /** The classified error, or `null` while not in the `error` status. */
+                      error: CameraStreamError | null;
+                      /** Attach to a `<video ref={…} />`. The stream is wired to it once ready. */
+                      videoRef: RefObject<HTMLVideoElement | null>;
+                      /**
+                       * The live stream, or `null`.
+                       *
+                       * Exposed for the things that need the **track** rather than the picture — the LED
+                       * torch (`useTorch`), the real frame size from `getSettings()`, recording it with
+                       * `useVideoRecorder`. Do not stop it yourself: the hook owns its lifetime and
+                       * releases it on unmount and on `retry()`.
+                       */
+                      stream: MediaStream | null;
+                      /** Manually re-attempt after an error (e.g. the user changed permissions). */
+                      retry: () => void;
+                  }
+
+                  /** Options for {@link useCameraStream}. */
+                  export declare interface UseCameraStreamOptions {
+                      /**
+                       * Constraints passed to `getUserMedia`. Defaults to the rear
+                       * ("environment") camera at Full-HD ideal resolution with audio off.
+                       * Read when the stream (re)starts — change it and call `retry()` to apply.
+                       */
+                      constraints?: MediaStreamConstraints;
+                      /**
+                       * Hold off acquiring the camera until this is `true`. Default `true`.
+                       *
+                       * The point is to be able to *not* prompt. A permission prompt costs the user a
+                       * decision and, if they refuse, costs the app the feature permanently — so a
+                       * surface that already knows it cannot do its job (a barcode scanner in a browser
+                       * with no decoder) must not open the camera to then say so. Flipping this to `false`
+                       * also releases a stream that is already live.
+                       */
+                      enabled?: boolean;
+                  }
+
+                  /**
+                   * Sample mean luminance from a `<video>` source on a `requestAnimationFrame`
+                   * loop and expose the rolling value. Sampling is throttled by `intervalMs` and
+                   * paused whenever `enabled` is `false` or the video is not ready yet
+                   * (`readyState < 2` or `videoWidth === 0`).
+                   *
+                   * One offscreen canvas is reused across frames to avoid GC pressure. Designed
+                   * to feed a live brightness bar / border color on a camera page.
+                   *
+                   * @param videoRef - ref to the `<video>` element to sample.
+                   * @param options - optional configuration (see {@link UseLiveLuminanceOptions}).
+                   * @returns The rolling mean luminance in `0..255` (`0` until the first sample).
+                   */
+                  export declare function useLiveLuminance(videoRef: RefObject<HTMLVideoElement | null>, { enabled, intervalMs }?: UseLiveLuminanceOptions): number;
+
+                  /** Options for {@link useLiveLuminance}. */
+                  export declare interface UseLiveLuminanceOptions {
+                      /** When `false` the loop is paused (e.g. while a capture is in flight). Default: `true`. */
+                      enabled?: boolean;
+                      /** Throttle measurements in milliseconds. Default: `160` (~6 fps), plenty for UX. */
+                      intervalMs?: number;
+                  }
+
+                  export declare const VERSION: string;
+
+                  export declare abstract class VisionTask {
+                      protected readonly _session: OrtSession;
+                      protected constructor(_session: OrtSession);
+                      /** The underlying {@link OrtSession} used to run inference. */
+                      get session(): OrtSession;
+                  }
+
+                  /**
+                   * Write an RGBA buffer as normalized planar float32.
+                   *
+                   * Shared by {@link ResizePipeline} and exported for a custom pipeline that
+                   * already holds pixels and wants the SDK's exact arithmetic.
+                   *
+                   * The expression is `(value / 255 - mean) / std`, evaluated in that order on
+                   * purpose: folding it into a single multiply-add (`value * k + b`) computes the
+                   * same quantity but rounds differently, and the tasks' output is asserted to be
+                   * bit-identical to the composable `normalize` → `toCHW` path.
+                   *
+                   * @param rgba Source pixels, 4 bytes per pixel, `width * height` long.
+                   * @param width Image width in pixels.
+                   * @param height Image height in pixels.
+                   * @param mean Per-channel RGB mean, already in `[0, 1]`.
+                   * @param std Per-channel RGB standard deviation.
+                   * @param out Destination buffer, `3 * width * height` long.
+                   * @param stride Bytes per source pixel: 4 for canvas RGBA, 3 for packed RGB.
+                   */
+                  export declare function writePlanarFloat32(rgba: Uint8ClampedArray | Uint8Array, width: number, height: number, mean: readonly [number, number, number], std: readonly [number, number, number], out: Float32Array, stride?: number): void;
+
+                  /**
+                   * Build a zero-filled CHW tensor payload for a warm-up run.
+                   *
+                   * @param width Model input width in pixels.
+                   * @param height Model input height in pixels.
+                   */
+                  export declare function zeroTensorData(width: number, height: number): Float32Array;
+
+                  export { }