runntime 0.0.1-alpha.0 → 0.0.1-beta.1

package/dist/zoo/index.d.mts

@@ -0,0 +1,671 @@
+import { n as initRunntime, t as Yolo26Variant } from "../config-UyxIidZc.mjs";
+//#region src/core/weights/cache.d.ts
+/** Platform-neutral weight-cache contract: the loaders accept any
+ *  implementation (web: OPFS via zoo's createOpfsCache; React Native:
+ *  expo-file-system in apps/mobile). Values must be non-empty — zero-byte
+ *  entries are treated as misses (crash artifacts of interrupted writes). */
+interface WeightCache {
+  get(key: string): Promise<ArrayBuffer | undefined>;
+  getOrCompute(key: string, compute: () => Promise<ArrayBufferView>): Promise<ArrayBuffer>;
+  /** Drop every entry whose key starts with `prefix`. One file's entries
+   *  share a key prefix (cachedRangeSource writes `st/<fileId>/<range>` per
+   *  tensor), so evicting a bad download means dropping a prefix, not a
+   *  single key. Callers recovering from one corrupt file MUST use this —
+   *  clear() throws away every other model the app has cached. */
+  deletePrefix(prefix: string): Promise<void>;
+  /** Drop everything. For a user-facing "clear cache", not error recovery. */
+  clear(): Promise<void>;
+}
+//#endregion
+//#region src/core/weights/safetensors.d.ts
+/** Bytes [begin, end) of a checkpoint file. Must return a standalone
+ *  Uint8Array at byteOffset 0, viewable at any width. */
+interface RangeSource {
+  read(begin: number, end: number): Promise<Uint8Array>;
+}
+export declare function bufferSource(buf: ArrayBuffer | Uint8Array): RangeSource;
+//#endregion
+//#region src/core/weights/opfsCache.d.ts
+/** OPFS-backed cache; returns undefined when OPFS is unavailable. */
+export declare function createOpfsCache(namespace: string): Promise<WeightCache | undefined>;
+//#endregion
+//#region src/zoo/load.d.ts
+/** Where the weights come from: a URL, or any byte-range reader. */
+type ModelPath = string | RangeSource;
+/** Options accepted by every create<Task>() factory. */
+interface LoadOptions {
+  /** Saves fetched bytes. The next load reads them from here, no network. */
+  cache?: WeightCache;
+  /** Cache key. Defaults to the URL's file name; required for a RangeSource. */
+  cacheId?: string;
+  /** Called while tensors upload: tensor name, bytes done, bytes total. */
+  onProgress?: (name: string, doneBytes: number, totalBytes: number) => void;
+  /** Called per fetched network chunk with its size in bytes. */
+  onBytes?: (chunkBytes: number) => void;
+  /** Stops the load between steps. A step already running finishes first. */
+  signal?: AbortSignal;
+}
+//#endregion
+//#region src/zoo/models.d.ts
+/** Ready-made model configs: the Hugging Face URLs of the weights and the
+ *  tokenizer, plus the options each variant needs. Pass one to a
+ *  create<Task>() call, or spread it and change a field.
+ *
+ *  Every family has a DEFAULT, the smallest download that runs everywhere,
+ *  and one entry per hosted precision or size. The files live in the
+ *  software-mansion `runntime-*` repos, one per model, laid out as
+ *  `<size>/<precision>/model.safetensors` with `tokenizer.json` at the
+ *  root where the model has one. */
+export declare const models: {
+  readonly textEmbedding: {
+    /** 384-dim sentence embeddings, 22M parameters. */
+    readonly ALL_MINILM_L6_V2: {
+      DEFAULT: {
+        tokenizerPath: string;
+      } & {
+        modelPath: string;
+      };
+      F16: {
+        tokenizerPath: string;
+      } & {
+        dtype: "f16";
+        modelPath: string;
+      };
+      F32: {
+        tokenizerPath: string;
+      } & {
+        modelPath: string;
+        dtype: "f32";
+      };
+    };
+  };
+  readonly privacyFilter: {
+    /** OpenAI's privacy-filter: 1.5B parameters, 50M active per token,
+     *  int8 weights in groups of 640. The one hosted format. */
+    readonly PRIVACY_FILTER: {
+      readonly DEFAULT: {
+        modelPath: string;
+      };
+    };
+  };
+  readonly speechToText: {
+    /** English. */
+    readonly MOONSHINE: {
+      /** 27M parameters. */
+      readonly TINY: {
+        DEFAULT: {
+          arch: "moonshine";
+          tokenizerPath: string;
+        } & {
+          modelPath: string;
+        };
+        F16: {
+          arch: "moonshine";
+          tokenizerPath: string;
+        } & {
+          dtype: "f16";
+          modelPath: string;
+        };
+        F32: {
+          arch: "moonshine";
+          tokenizerPath: string;
+        } & {
+          modelPath: string;
+          dtype: "f32";
+        };
+      };
+      /** 61M parameters. More accurate, slower. */
+      readonly BASE: {
+        DEFAULT: {
+          arch: "moonshine";
+          tokenizerPath: string;
+        } & {
+          modelPath: string;
+        };
+        F16: {
+          arch: "moonshine";
+          tokenizerPath: string;
+        } & {
+          dtype: "f16";
+          modelPath: string;
+        };
+        F32: {
+          arch: "moonshine";
+          tokenizerPath: string;
+        } & {
+          modelPath: string;
+          dtype: "f32";
+        };
+      };
+    };
+    /** English, the streaming family. */
+    readonly MOONSHINE_STREAMING: {
+      /** 34M parameters. */
+      readonly TINY: {
+        DEFAULT: {
+          arch: "moonshine-streaming";
+          tokenizerPath: string;
+        } & {
+          modelPath: string;
+        };
+        F16: {
+          arch: "moonshine-streaming";
+          tokenizerPath: string;
+        } & {
+          dtype: "f16";
+          modelPath: string;
+        };
+        F32: {
+          arch: "moonshine-streaming";
+          tokenizerPath: string;
+        } & {
+          modelPath: string;
+          dtype: "f32";
+        };
+      };
+    };
+  };
+  readonly objectDetection: {
+    /** YOLO26 detect, COCO-80 classes, f16 weights. */
+    readonly YOLO26: {
+      readonly DEFAULT: {
+        modelPath: string;
+      };
+      /** The nano size, 5 MB. */
+      readonly N: {
+        modelPath: string;
+      };
+      /** The small size, 18 MB. */
+      readonly S: {
+        modelPath: string;
+      };
+      /** The medium size, 39 MB. More accurate, slower. */
+      readonly M: {
+        modelPath: string;
+      };
+    };
+  };
+  readonly instanceSegmentation: {
+    /** YOLO26 segment, COCO-80 classes with a mask per object, f16 weights. */
+    readonly YOLO26_SEG: {
+      readonly DEFAULT: {
+        modelPath: string;
+      };
+      /** The nano size, 5 MB. */
+      readonly N: {
+        modelPath: string;
+      };
+      /** The small size, 20 MB. */
+      readonly S: {
+        modelPath: string;
+      };
+      /** The medium size, 45 MB. More accurate, slower. */
+      readonly M: {
+        modelPath: string;
+      };
+    };
+  };
+  readonly keypointDetection: {
+    /** YOLO26 pose, people with 17 COCO landmarks, f16 weights. */
+    readonly YOLO26_POSE: {
+      readonly DEFAULT: {
+        modelPath: string;
+      };
+      /** The nano size, 6 MB. */
+      readonly N: {
+        modelPath: string;
+      };
+      /** The small size, 20 MB. */
+      readonly S: {
+        modelPath: string;
+      };
+      /** The medium size, 42 MB. More accurate, slower. */
+      readonly M: {
+        modelPath: string;
+      };
+    };
+  };
+  readonly depthEstimation: {
+    /** DepthART relative depth at 448×448, f16 weights. */
+    readonly DEPTHART: {
+      readonly DEFAULT: {
+        modelPath: string;
+      };
+      /** The small size, 13 MB. */
+      readonly S: {
+        modelPath: string;
+      };
+      /** The base size, 24 MB. More detail, slower. */
+      readonly B: {
+        modelPath: string;
+      };
+    };
+  };
+  readonly imageClassification: {
+    /** MobileNetV4 conv, ImageNet-1k, f16 weights. The model runs in f16
+     *  only, so each size has one entry. */
+    readonly MOBILENETV4: {
+      readonly DEFAULT: {
+        modelPath: string;
+      };
+      /** The small size, 3.8M parameters, 10 MB. */
+      readonly SMALL: {
+        modelPath: string;
+      };
+    };
+  };
+};
+//#endregion
+//#region src/zoo/tasks/nlp/textEmbedding.d.ts
+/** What to load. Every field is optional; a missing one comes from
+ *  models.textEmbedding.ALL_MINILM_L6_V2.default. */
+interface TextEmbedderModel {
+  /** The safetensors checkpoint. */
+  readonly modelPath?: ModelPath;
+  /** The tokenizer JSON: a Hugging Face tokenizer.json or our compact asset. */
+  readonly tokenizerPath?: string;
+  /** Precision on the GPU. `f16` runs the whole model in half precision,
+   *  weights and activations, for half the memory traffic; results move by
+   *  about 1e-3. Needs a device with `shader-f16`. Default: `f16` where
+   *  the device has it, `f32` elsewhere. Either loads any weight file. */
+  readonly dtype?: 'f32' | 'f16';
+  /** Longest input in tokens, [CLS] and [SEP] included. Longer text is cut.
+   *  Default 256, the model card's limit. */
+  readonly maxTokens?: number;
+}
+interface TextEmbedder {
+  /** Length of every returned vector. */
+  readonly dim: number;
+  /** One text → unit-length vector. */
+  embed(input: string): Promise<Float32Array>;
+  /** Many texts in one GPU pass. Much faster than embed() in a loop. */
+  embedBatch(inputs: readonly string[]): Promise<Float32Array[]>;
+  /** Frees the weights and every GPU buffer the runner holds. */
+  dispose(): void;
+}
+/** Dot product of two unit-length embeddings, which is their cosine
+ *  similarity: 1 for the same meaning, near 0 for unrelated text. */
+export declare function similarity(a: Float32Array, b: Float32Array): number;
+/** Loads the checkpoint and the tokenizer, warms every GPU path once, and
+ *  returns the runner. With no config, loads all-MiniLM-L6-v2 from the
+ *  Hugging Face Hub. */
+export declare function createTextEmbedder(config?: TextEmbedderModel, opts?: LoadOptions): Promise<TextEmbedder>;
+//#endregion
+//#region src/zoo/tasks/nlp/privacyFilter.d.ts
+/** What to load. With no config, the int8 export from the Hugging Face
+ *  Hub, models.privacyFilter.PRIVACY_FILTER.DEFAULT. */
+interface PrivacyFilterModel {
+  /** The safetensors checkpoint: the hosted int8 export, or your own int8,
+   *  f16 or bf16 export of the official file. The weight format comes from
+   *  the file. */
+  readonly modelPath?: ModelPath;
+}
+/** One piece of personal data found in the text. */
+interface PrivacySpan {
+  /** The kind of data: `private_person`, `private_email`, `private_phone`,
+   *  `private_address`, `private_date`, `private_url`, `account_number`
+   *  or `secret`. */
+  readonly label: string;
+  /** Where it sits in the text, as string indices. `end` is exclusive. */
+  readonly start: number;
+  readonly end: number;
+  /** The matched text, `text.slice(start, end)`. */
+  readonly text: string;
+  /** A tag to put in its place, like `<PRIVATE_EMAIL>`. */
+  readonly placeholder: string;
+}
+interface PrivacyFilter {
+  /** Text in, every span of personal data in it out, in text order.
+   *  Empty text gives an empty list. */
+  detect(text: string): Promise<PrivacySpan[]>;
+  /** Frees the weights and every GPU buffer the runner holds. */
+  dispose(): void;
+}
+/** Loads the checkpoint, warms the GPU path once, and returns the runner. */
+export declare function createPrivacyFilter(config?: PrivacyFilterModel, opts?: LoadOptions): Promise<PrivacyFilter>;
+//#endregion
+//#region src/zoo/tasks/audio/speechToText.d.ts
+/** The two Moonshine families. Each has its own weights and decoder. */
+type SpeechToTextArch = 'moonshine' | 'moonshine-streaming';
+/** What to load. Every field is optional; a missing one comes from the
+ *  family's default entry in models.speechToText. */
+interface SpeechToTextModel {
+  /** The family the weights belong to. Default `moonshine`. */
+  readonly arch?: SpeechToTextArch;
+  /** The safetensors checkpoint. */
+  readonly modelPath?: ModelPath;
+  /** The tokenizer JSON: a Hugging Face tokenizer.json or our compact asset. */
+  readonly tokenizerPath?: string;
+  /** Precision on the GPU. `f16` runs the whole model in half precision,
+   *  weights and activations, for half the memory traffic; the text stays
+   *  the same. Needs a device with `shader-f16`. Default: `f16` where the
+   *  device has it, `f32` elsewhere. Either loads any weight file. */
+  readonly dtype?: 'f32' | 'f16';
+}
+/** One update of a live stream: the whole transcript so far. */
+interface SpeechStreamUpdate {
+  /** The sentences the speaker finished. Each ended in a pause. */
+  readonly committed: string;
+  /** The sentence being spoken now. It changes until it commits. */
+  readonly nonCommitted: string;
+}
+interface SpeechToText {
+  /** Mono samples at 16 kHz in, the spoken text out. Long clips are split
+   *  on quiet moments. Clips shorter than one model frame give ''. */
+  transcribe(audio: Float32Array): Promise<string>;
+  /** Starts live transcription: feed samples with streamInsert, read the
+   *  updates here. An update comes when the text changes; the iterator
+   *  ends after streamStop or dispose. One stream at a time. */
+  stream(): AsyncIterable<SpeechStreamUpdate>;
+  /** Adds microphone samples, mono at 16 kHz, to the open stream. */
+  streamInsert(samples: Float32Array): void;
+  /** Commits what is left in the open stream and ends its iterator. */
+  streamStop(): void;
+  /** Frees the weights and every GPU buffer the runner holds. */
+  dispose(): void;
+}
+/** Loads the checkpoint and the tokenizer, warms every GPU path once, and
+ *  returns the runner. With no config, loads Moonshine tiny from the
+ *  Hugging Face Hub. */
+export declare function createSpeechToText(config?: SpeechToTextModel, opts?: LoadOptions): Promise<SpeechToText>;
+//#endregion
+//#region src/zoo/tasks/audio/audioInput.d.ts
+/** Audio input helpers: an encoded clip or raw microphone samples in, the
+ *  16 kHz mono Float32Array the speech models take out. Both use the
+ *  browser's own decoder and resampler through an OfflineAudioContext, so
+ *  they run in the browser only. Importing the file is safe anywhere, the
+ *  browser objects appear only inside the functions. */
+/** Sample rate the speech models take. */
+export declare const SPEECH_SAMPLE_RATE = 16000;
+/** Decodes any clip the browser can play (wav, mp3, ogg, ...) to 16 kHz
+ *  mono samples. Stereo is mixed down to one channel. */
+export declare function decodeAudio(data: ArrayBuffer): Promise<Float32Array>;
+/** Resamples raw mono samples recorded at `sourceRate` to 16 kHz. Returns
+ *  the input as is when it is already at 16 kHz. Use it on microphone
+ *  samples, a lossy re-encode is not needed. */
+export declare function resampleAudio(samples: Float32Array, sourceRate: number): Promise<Float32Array>;
+//#endregion
+//#region src/zoo/tasks/cv/image.d.ts
+/** Raw CPU image types shared by every vision task. */
+/** Pixel formats an ImageBuffer can carry: which channels, in what order. */
+type ImageFormat = 'rgb' | 'rgba' | 'bgr' | 'bgra' | 'gray';
+/** A raw image in memory: one row after another, all channels of one pixel
+ *  together (the way a canvas or a camera gives it). */
+interface ImageBuffer {
+  readonly data: Uint8Array | Uint8ClampedArray;
+  readonly width: number;
+  readonly height: number;
+  readonly format: ImageFormat;
+  readonly layout: 'hwc';
+}
+/** How an image is fitted into the model's input size.
+ *  - `stretch`: scale width and height separately; nothing is cut or padded.
+ *  - `letterbox`: keep the aspect ratio, pad the rest with a flat color.
+ *  - `crop`: keep the aspect ratio, cut the centered square, then scale. */
+type ResizeMode = 'stretch' | 'letterbox' | 'crop';
+/** Wraps raw bytes as an ImageBuffer. Checks the size and the byte count. */
+export declare function imageBuffer(data: Uint8Array | Uint8ClampedArray, width: number, height: number, format?: ImageFormat): ImageBuffer;
+/** Views canvas ImageData as an ImageBuffer. No copy. */
+export declare function imageBufferFromImageData(img: ImageData): ImageBuffer;
+//#endregion
+//#region src/zoo/tasks/cv/ops/point.d.ts
+interface Point {
+  readonly x: number;
+  readonly y: number;
+}
+interface Size {
+  readonly width: number;
+  readonly height: number;
+}
+//#endregion
+//#region src/zoo/tasks/cv/ops/box.d.ts
+/** Each box format and the fields it carries. */
+type BoxMap = Readonly<{
+  xyxy: Readonly<{
+    xmin: number;
+    ymin: number;
+    xmax: number;
+    ymax: number;
+  }>;
+  xywh: Readonly<{
+    xmin: number;
+    ymin: number;
+    w: number;
+    h: number;
+  }>;
+  cxcywh: Readonly<{
+    cx: number;
+    cy: number;
+    w: number;
+    h: number;
+  }>;
+}>;
+type BoxFormat = keyof BoxMap;
+/** A box tagged with its format. */
+type BoundingBox<F extends BoxFormat = BoxFormat> = F extends BoxFormat ? {
+  readonly format: F;
+} & BoxMap[F] : never;
+//#endregion
+//#region src/zoo/tasks/cv/objectDetection.d.ts
+/** What to load. Every field is optional; a missing `modelPath` comes from
+ *  models.objectDetection.YOLO26.DEFAULT. */
+interface ObjectDetectorModel {
+  /** The weights: a safetensors export of a YOLO26 detect checkpoint. */
+  readonly modelPath?: ModelPath;
+  /** Model size, `n` to `x`. Default: read from the weights. */
+  readonly variant?: Yolo26Variant;
+  /** Input width and height in pixels, a multiple of 32. Default 640.
+   *  Smaller runs faster and misses more small objects. */
+  readonly inputSize?: number;
+  /** How an image is fitted into the model input. Default `letterbox`. */
+  readonly resizeMode?: ResizeMode;
+}
+interface DetectObjectsOptions {
+  /** Drops objects scored below this, 0 to 1. Default 0.3. */
+  readonly confidenceThreshold?: number;
+  /** At most this many objects, best first. Default 300. */
+  readonly maxDetections?: number;
+}
+/** One object found in the image. */
+interface ObjectDetection {
+  /** The class name, like `person` or `bus`. */
+  readonly label: string;
+  /** The class index into `labels`. */
+  readonly classId: number;
+  /** The score, 0 to 1. */
+  readonly confidence: number;
+  /** Where it sits, in pixels of the input image. */
+  readonly box: BoundingBox<'xyxy'>;
+}
+interface ObjectDetector {
+  /** The class names, by class index. */
+  readonly labels: readonly string[];
+  /** Image in, the objects in it out, best first. */
+  detectObjects(image: ImageBuffer, options?: DetectObjectsOptions): Promise<ObjectDetection[]>;
+  /** Frees the weights and every GPU buffer the runner holds. */
+  dispose(): void;
+}
+/** Loads the checkpoint, warms the GPU path once, and returns the runner.
+ *  Needs a device with `shader-f16`. */
+export declare function createObjectDetector(config?: ObjectDetectorModel, opts?: LoadOptions): Promise<ObjectDetector>;
+//#endregion
+//#region src/zoo/tasks/cv/instanceSegmentation.d.ts
+/** What to load. Every field is optional; a missing `modelPath` comes from
+ *  models.instanceSegmentation.YOLO26_SEG.DEFAULT. */
+interface InstanceSegmenterModel {
+  /** The weights: a safetensors export of a YOLO26 segment checkpoint. */
+  readonly modelPath?: ModelPath;
+  /** Model size, `n` to `x`. Default: read from the weights. */
+  readonly variant?: Yolo26Variant;
+  /** Input width and height in pixels, a multiple of 32. Default 640.
+   *  Smaller runs faster and misses more small objects. */
+  readonly inputSize?: number;
+  /** How an image is fitted into the model input. Default `letterbox`. */
+  readonly resizeMode?: ResizeMode;
+}
+interface SegmentInstancesOptions {
+  /** Drops objects scored below this, 0 to 1. Default 0.3. */
+  readonly confidenceThreshold?: number;
+  /** At most this many objects, best first. Default 300. */
+  readonly maxDetections?: number;
+}
+/** One object found in the image. */
+interface InstanceSegmentation {
+  /** The class name, like `person` or `bus`. */
+  readonly label: string;
+  /** The class index into `labels`. */
+  readonly classId: number;
+  /** The score, 0 to 1. */
+  readonly confidence: number;
+  /** Where it sits, in pixels of the input image. */
+  readonly box: BoundingBox<'xyxy'>;
+  /** Which pixels of `box` are the object: a `gray` image that covers the
+   *  box, at about a quarter of the model input's resolution. 0 is outside
+   *  the object, 255 inside, in between along the edge. Stretch it over
+   *  `box` when drawing. */
+  readonly mask: ImageBuffer;
+}
+interface InstanceSegmenter {
+  /** The class names, by class index. */
+  readonly labels: readonly string[];
+  /** Image in, the objects in it out, best first. */
+  segmentInstances(image: ImageBuffer, options?: SegmentInstancesOptions): Promise<InstanceSegmentation[]>;
+  /** Frees the weights and every GPU buffer the runner holds. */
+  dispose(): void;
+}
+/** Loads the checkpoint, warms the GPU path once, and returns the runner.
+ *  Needs a device with `shader-f16`. */
+export declare function createInstanceSegmenter(config?: InstanceSegmenterModel, opts?: LoadOptions): Promise<InstanceSegmenter>;
+//#endregion
+//#region src/zoo/yolo26/pipeline.d.ts
+/** The 17 COCO body landmarks, in model output order. */
+export declare const COCO_LANDMARKS: readonly ["nose", "leftEye", "rightEye", "leftEar", "rightEar", "leftShoulder", "rightShoulder", "leftElbow", "rightElbow", "leftWrist", "rightWrist", "leftHip", "rightHip", "leftKnee", "rightKnee", "leftAnkle", "rightAnkle"];
+type CocoLandmark = (typeof COCO_LANDMARKS)[number];
+//#endregion
+//#region src/zoo/tasks/cv/keypointDetection.d.ts
+/** What to load. Every field is optional; a missing `modelPath` comes from
+ *  models.keypointDetection.YOLO26_POSE.DEFAULT. */
+interface KeypointDetectorModel {
+  /** The weights: a safetensors export of a YOLO26 pose checkpoint. */
+  readonly modelPath?: ModelPath;
+  /** Model size, `n` to `x`. Default: read from the weights. */
+  readonly variant?: Yolo26Variant;
+  /** Input width and height in pixels, a multiple of 32. Default 640.
+   *  Smaller runs faster and misses more small people. */
+  readonly inputSize?: number;
+  /** How an image is fitted into the model input. Default `letterbox`. */
+  readonly resizeMode?: ResizeMode;
+}
+interface DetectKeypointsOptions {
+  /** Drops people scored below this, 0 to 1. Default 0.3. */
+  readonly confidenceThreshold?: number;
+  /** At most this many people, best first. Default 300. */
+  readonly maxDetections?: number;
+}
+/** One landmark of a person, in pixels of the input image. */
+interface Landmark extends Point {
+  /** How sure the model is the landmark is visible, 0 to 1. A hidden one
+   *  keeps a position guess with a low value. */
+  readonly confidence: number;
+}
+/** One person found in the image. */
+interface KeypointDetection {
+  /** Where the person sits, in pixels of the input image. */
+  readonly box: BoundingBox<'xyxy'>;
+  /** The score, 0 to 1. */
+  readonly confidence: number;
+  /** The 17 COCO landmarks by name, `nose` to `rightAnkle`. A landmark
+   *  outside the image keeps its position. */
+  readonly landmarks: Readonly<Record<CocoLandmark, Landmark>>;
+}
+interface KeypointDetector {
+  /** The landmark names, in `COCO_LANDMARKS` order. */
+  readonly landmarkNames: readonly CocoLandmark[];
+  /** Pairs of landmark names to draw as limbs. */
+  readonly skeleton: readonly (readonly [CocoLandmark, CocoLandmark])[];
+  /** Image in, the people in it out, best first. */
+  detectKeypoints(image: ImageBuffer, options?: DetectKeypointsOptions): Promise<KeypointDetection[]>;
+  /** Frees the weights and every GPU buffer the runner holds. */
+  dispose(): void;
+}
+/** Loads the checkpoint, warms the GPU path once, and returns the runner.
+ *  Needs a device with `shader-f16`. */
+export declare function createKeypointDetector(config?: KeypointDetectorModel, opts?: LoadOptions): Promise<KeypointDetector>;
+//#endregion
+//#region src/zoo/depthart/estimator.d.ts
+type DepthartVariant = 'b' | 's';
+//#endregion
+//#region src/zoo/tasks/cv/depthEstimation.d.ts
+/** What to load. Every field is optional; a missing `modelPath` comes from
+ *  models.depthEstimation.DEPTHART.DEFAULT. */
+interface DepthEstimatorModel {
+  /** The weights: a safetensors export of a DepthART relative checkpoint. */
+  readonly modelPath?: ModelPath;
+  /** Model size, `b` or `s`. Default: read from the weights. */
+  readonly variant?: DepthartVariant;
+  /** How an image is fitted into the model input. Default `stretch`, so
+   *  the map covers the whole image. */
+  readonly resizeMode?: ResizeMode;
+}
+/** Relative depth of the model input, one value per pixel, row by row.
+ *  Smaller = nearer. Values have no unit: compare them within one map. */
+interface DepthMap {
+  readonly width: number;
+  readonly height: number;
+  readonly data: Float32Array;
+}
+interface DepthEstimator {
+  /** Width and height of every returned map. */
+  readonly inputSize: number;
+  /** Image in, its depth map out. */
+  estimateDepth(image: ImageBuffer): Promise<DepthMap>;
+  /** Frees the weights and every GPU buffer the runner holds. */
+  dispose(): void;
+}
+/** Loads the checkpoint, warms the GPU path once, and returns the runner. */
+export declare function createDepthEstimator(config?: DepthEstimatorModel, opts?: LoadOptions): Promise<DepthEstimator>;
+//#endregion
+//#region src/zoo/mobilenetv4/pipeline.d.ts
+/** CPU pre/post-processing around the MobileNetV4 GPU forward.
+ *  Preprocess: RGBA canvas pixels → [3, S, S] CHW f32, ImageNet-normalized.
+ */
+interface Classification {
+  classId: number;
+  confidence: number;
+}
+//#endregion
+//#region src/zoo/tasks/cv/imageClassification.d.ts
+/** What to load. With no config, MobileNetV4-Conv-S from the Hugging Face
+ *  Hub with the ImageNet class names. */
+interface ImageClassifierModel {
+  /** The weights: a MobileNetV4-Conv-S safetensors file, 1000 ImageNet classes. */
+  readonly modelPath?: ModelPath;
+  /** The class names, by class index; as many as the model has classes.
+   *  Default: the 1000 ImageNet names. */
+  readonly labels?: readonly string[];
+  /** How an image is fitted into the model input. Default `crop`, the
+   *  middle 87.5% of the centered square, the crop the model was evaluated
+   *  with; it keeps the subject's proportions. */
+  readonly resizeMode?: ResizeMode;
+}
+interface ClassifyOptions {
+  /** How many classes to return, best first. Default: all of them. */
+  readonly topk?: number;
+}
+interface ImageClassifier {
+  /** The class names, by class index. */
+  readonly labels: readonly string[];
+  /** Width and height of the model input in pixels. */
+  readonly inputSize: number;
+  /** Image in, its most likely classes out, best first. */
+  classify(image: ImageBuffer, options?: ClassifyOptions): Promise<(Classification & {
+    label: string;
+  })[]>;
+  /** Frees the weights and every GPU buffer the runner holds. */
+  dispose(): void;
+}
+/** Loads the checkpoint, warms the GPU path once, and returns the runner.
+ *  Needs a device with `shader-f16`. */
+export declare function createImageClassifier(config?: ImageClassifierModel, opts?: LoadOptions): Promise<ImageClassifier>;
+//#endregion
+export { type BoundingBox, type BoxFormat, type BoxMap, type Classification, type ClassifyOptions, type CocoLandmark, type DepthEstimator, type DepthEstimatorModel, type DepthMap, type DepthartVariant, type DetectKeypointsOptions, type DetectObjectsOptions, type ImageBuffer, type ImageClassifier, type ImageClassifierModel, type ImageFormat, type InstanceSegmentation, type InstanceSegmenter, type InstanceSegmenterModel, type KeypointDetection, type KeypointDetector, type KeypointDetectorModel, type Landmark, type LoadOptions, type ModelPath, type ObjectDetection, type ObjectDetector, type ObjectDetectorModel, type Point, type PrivacyFilter, type PrivacyFilterModel, type PrivacySpan, type RangeSource, type ResizeMode, type SegmentInstancesOptions, type Size, type SpeechStreamUpdate, type SpeechToText, type SpeechToTextArch, type SpeechToTextModel, type TextEmbedder, type TextEmbedderModel, type WeightCache, type Yolo26Variant, initRunntime };