runntime 0.1.0 → 0.2.0

package/dist/{config-UyxIidZc.d.mts → config-DZyZ2TdH.d.mts}

@@ -11,14 +11,16 @@ declare const ACT_CODE: {
   readonly gelu: 2;
   readonly silu: 3;
   readonly relu: 4;
+  readonly geluTanh: 5;
 };
 type ActName = keyof typeof ACT_CODE;
 type SlotAct = Exclude<ActName, 'none'>;
 //#endregion
 //#region src/core/graph/ops/matmul.d.ts
-/** Options for matmul. `bias` and `addend` are fused epilogue adds, not
- *  available for quantW. `baseRow` views into a taller weight without copying,
- *  so MoE experts stay views into one fused tensor. */
+/** Options for matmul. `bias` and `addend` are fused epilogue adds; on a
+ *  quantW weight they need the whole weight, no baseRow or scaleBase view.
+ *  `baseRow` views into a taller weight without copying, so MoE experts stay
+ *  views into one fused tensor. */
 interface MatmulOpts {
   bias?: Value;
   addend?: Value;
@@ -49,7 +51,7 @@ interface ValueMeta {
 /** The storage buffer behind a materialized Value. */
 type GpuBufferRef = F32Buffer | F16Buffer | U32Buffer;
 /** Every op a pending node can name. */
-type OpName = 'add' | 'mul' | 'sub' | 'swiglu' | 'swigluChunk' | 'rsqrt' | 'addScalar' | 'sigmoid' | 'mulScalar' | 'clampScalar' | 'tanh' | 'gelu' | 'silu' | 'asinh' | 'matmul' | 'matmulQuantW' | 'matmulGatherQuantW' | 'matmulGather' | 'argmaxDot' | 'attn' | 'rope' | 'conv1d' | 'convTranspose2d' | 'conv2dHwc4' | 'maxPool2dHwc4' | 'upsample2dHwc4' | 'avgPool2dHwc4' | 'pad2dHwc4' | 'resizeBilinearHwc4' | 'channelAffineHwc4' | 'concatChannelsHwc4' | 'sliceChannelsHwc4' | 'toHwc4' | 'toChw' | 'ssmScanProject' | 'ssmSelectiveScan' | 'ssmScanMerge' | 'softmax' | 'mean' | 'meanSquare' | 'layerNorm' | 'topk' | 'astype' | 'transpose' | 'sliceCols' | 'concatCols' | 'sliceRows' | 'concatRows' | 'reshape' | 'sliceChannels' | 'concatChannels' | 'writeRows' | 'gatherRowsFrom' | 'gatherRows';
+type OpName = 'add' | 'mul' | 'sub' | 'swiglu' | 'swigluChunk' | 'rsqrt' | 'addScalar' | 'sigmoid' | 'mulScalar' | 'clampScalar' | 'tanh' | 'gelu' | 'silu' | 'asinh' | 'matmul' | 'matmulQuantW' | 'matmulGather' | 'moeUp' | 'moeDown' | 'argmaxDot' | 'attn' | 'localAttention' | 'rope' | 'conv1d' | 'gluConv1d' | 'convTranspose2d' | 'conv2dHwc4' | 'maxPool2dHwc4' | 'upsample2dHwc4' | 'avgPool2dHwc4' | 'pad2dHwc4' | 'resizeBilinearHwc4' | 'channelAffineHwc4' | 'concatChannelsHwc4' | 'sliceChannelsHwc4' | 'toHwc4' | 'toChw' | 'ssmScanProject' | 'ssmSelectiveScan' | 'ssmScanMerge' | 'softmax' | 'mean' | 'layerNorm' | 'rmsNorm' | 'topk' | 'astype' | 'transpose' | 'sliceCols' | 'concatCols' | 'sliceRows' | 'concatRows' | 'reshape' | 'sliceChannels' | 'concatChannels' | 'writeRows' | 'gatherRowsFrom' | 'gatherRows';
 /** The recipe for a not-yet-computed Value. Inputs may themselves be pending,
  *  so chained ops form the DAG eval() walks. */
 interface PendingOp {
@@ -154,19 +156,30 @@ interface FusedReadback {
   /** toArray with the copy fused into the eval's own submit. */
   toArrayFused(value: Value): Promise<Float32Array>;
 }
-type RunntimeExecutor = Executor & Readback & Releaser & CaptureExecutor & FusedReadback;
-/** Sets the default device and returns its executor. Call it once at startup;
- *  tensor(), toArray() and loadStateDict() then need no root. */
+/** Frees pooled buffers a model has stopped using. */
+interface TrimExecutor {
+  /** Destroys the free pooled buffers of every size no eval has used since
+   *  the last trim. A model whose input length varies calls it after each
+   *  call, or its pool keeps a set of buffers for every length it has seen.
+   *  Does nothing once captured: the replay owns the pool's buffers. */
+  trim(): void;
+}
+type RunntimeExecutor = Executor & Readback & Releaser & CaptureExecutor & FusedReadback & TrimExecutor;
+/** Sets the device every model runs on and returns its executor. Call it
+ *  once at startup, before the first create<Task>(). */
 declare function initRunntime(root: TgpuRoot): RunntimeExecutor;
 /** Capture and replay: records one frame's dispatches, then re-submits them
  *  without walking the graph again. Fixed-shape forwards only. */
 interface CaptureExecutor {
   /** Runs `fn` once, recording every dispatch. The executor is replay-only
-   *  afterwards. Keep `targets` — their buffers stay valid across replays — and
+   *  afterwards, until dispose(), which also ends the replays. Keep `targets` — their buffers stay valid across replays — and
    *  overwrite inputs in place before each replay. */
   captureFrame<T>(fn: () => T): {
     targets: T;
     replay: () => void;
+    /** Records the frame's dispatches into `encoder` without submitting, so
+     *  other work can run before and after it in one command buffer. */
+    encodeReplay: (encoder: GPUCommandEncoder) => void;
     /** Replays once with a timestamp pair per dispatch. Per-dispatch passes
      *  remove overlap, so read the sum as relative attribution only. */
     profileReplay: () => Promise<KernelTiming[] | undefined>;

package/dist/zoo/index.d.mts

@@ -1,17 +1,15 @@
-import { n as initRunntime, t as Yolo26Variant } from "../config-UyxIidZc.mjs";
+import { n as initRunntime, t as Yolo26Variant } from "../config-DZyZ2TdH.mjs";
+import { RenderFlag, SampledFlag, TgpuBuffer, TgpuCommandEncoder, TgpuTexture, d } from "typegpu";
 //#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). */
+/** Keeps downloaded weights between visits. createOpfsCache() is the
+ *  built-in one; any object with these methods works. An entry with no bytes
+ *  counts as missing. */
 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. */
+  /** Drops every entry whose key starts with `prefix`. The entries of one
+   *  file share a prefix, so this removes one bad download and keeps the
+   *  other models. */
   deletePrefix(prefix: string): Promise<void>;
   /** Drop everything. For a user-facing "clear cache", not error recovery. */
   clear(): Promise<void>;
@@ -23,8 +21,24 @@ interface WeightCache {
 interface RangeSource {
   read(begin: number, end: number): Promise<Uint8Array>;
 }
+/** Wraps bytes already in memory as a RangeSource, for a `modelPath` that is
+ *  not a URL. */
 export declare function bufferSource(buf: ArrayBuffer | Uint8Array): RangeSource;
 //#endregion
+//#region src/core/error.d.ts
+/** An error with a `code`. Apps check the code, not the message. The
+ *  message is for people and can change between versions. */
+export declare const RUNNTIME_ERROR_CODES: readonly ["LOAD_FAILED", "LOAD_ABORTED", "CHECKPOINT_MISMATCH", "UNSUPPORTED_DEVICE", "EXECUTION_FAILED", "INVALID_ARGUMENT", "RESOURCE_DISPOSED", "NOT_INITIALIZED"];
+type RunntimeErrorCode = (typeof RUNNTIME_ERROR_CODES)[number];
+export declare class RunntimeError<C extends RunntimeErrorCode = RunntimeErrorCode> extends Error {
+  readonly code: C;
+  constructor(code: C, message: string, options?: ErrorOptions);
+}
+/** True when `value` is a RunntimeError, with this `code` if one is given.
+ *  Checks `name` and `code`, not the class, so it works even when a page
+ *  loads two copies of the library. */
+export declare function isRunntimeError<C extends RunntimeErrorCode>(value: unknown, code?: C): value is RunntimeError<C>;
+//#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>;
@@ -46,6 +60,28 @@ interface LoadOptions {
   signal?: AbortSignal;
 }
 //#endregion
+//#region src/zoo/tasks/gpu.d.ts
+/** An image already on the GPU. A texel's [0, 1] value stands for a byte
+ *  0–255, as in an ImageBuffer. */
+type GpuImage = GPUTexture | GPUExternalTexture | (TgpuTexture & SampledFlag);
+/** A texture the runner draws into. */
+type GpuImageTarget = GPUTexture | (TgpuTexture & RenderFlag);
+/** A buffer laid out as `Schema`. A raw GPUBuffer must hold the same bytes. */
+type GpuTensor<Schema extends d.BaseData> = GPUBuffer | TgpuBuffer<Schema>;
+/** A command encoder to record into. A TgpuCommandEncoder comes from
+ *  `root['~unstable'].createCommandEncoder()`. */
+type GpuEncoder = GPUCommandEncoder | TgpuCommandEncoder;
+/** The options every encode<Verb> method takes. Every resource must come from
+ *  the device passed to initRunntime(). */
+interface EncodeOptions<Source, Target> {
+  readonly source: Source;
+  readonly target: Target;
+  /** Records into this encoder, and the caller finishes and submits it,
+   *  before disposing the runner. It must not have an open pass. Default: a
+   *  new encoder, submitted before the method returns. */
+  readonly encoder?: GpuEncoder;
+}
+//#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
@@ -57,8 +93,33 @@ interface LoadOptions {
  *  `<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 embedding: {
+    /** Google's EmbeddingGemma 2: text in 100+ languages and code, images
+     *  and video in one 768-dim space, inputs up to 2048 tokens. 270M
+     *  parameters in the text model, 170M in the vision tower. */
+    readonly EMBEDDINGGEMMA_2: {
+      DEFAULT: {
+        modelPath: string;
+        visionPath: string;
+        audioPath: string;
+        tokenizerPath: string;
+      };
+      F16: {
+        dtype: "f16";
+        modelPath: string;
+        visionPath: string;
+        audioPath: string;
+        tokenizerPath: string;
+      };
+      F32: {
+        dtype: "f32";
+        modelPath: string;
+        visionPath: string;
+        audioPath: string;
+        tokenizerPath: string;
+      };
+    };
+    /** all-MiniLM-L6-v2: English text in 384-dim vectors, 22M parameters. */
     readonly ALL_MINILM_L6_V2: {
       DEFAULT: {
         tokenizerPath: string;
@@ -256,40 +317,122 @@ export declare const models: {
   };
 };
 //#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. */
+//#region src/zoo/embeddinggemma2/config.d.ts
+/** Token budgets an image may take, most tokens for the most detail. */
+declare const IMAGE_TOKEN_BUDGETS: readonly [70, 140, 280, 560, 1120];
+/** The instruction each task puts before the text (the checkpoint's
+ *  sentence-transformers prompts). `query` and `document` are the two sides
+ *  of search: queries get one, the texts searched get the other. */
+declare const EMBEDDINGGEMMA2_PROMPTS: {
+  readonly query: "task: search result | query: ";
+  readonly document: "title: none | text: ";
+  readonly questionAnswering: "task: question answering | query: ";
+  readonly factChecking: "task: fact checking | query: ";
+  readonly classification: "task: classification | query: ";
+  readonly clustering: "task: clustering | query: ";
+  readonly similarity: "task: sentence similarity | query: ";
+  readonly codeRetrieval: "task: code retrieval | query: ";
+};
+//#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/multimodal/embedding.d.ts
+/** What a text is for. Each task adds the instruction the model was
+ *  trained with. */
+type EmbeddingTask = keyof typeof EMBEDDINGGEMMA2_PROMPTS;
+/** Most tokens one image takes: 70, 140, 280, 560 or 1120. */
+type ImageTokenBudget = (typeof IMAGE_TOKEN_BUDGETS)[number];
+/** One piece of an input: text, an image, a video as its frames, or an
+ *  audio clip as mono samples at 16 kHz. */
+type EmbedPart = string | {
+  readonly image: ImageBuffer;
+} | {
+  readonly video: readonly ImageBuffer[];
+} | {
+  readonly audio: Float32Array;
+};
+/** What embed() takes: one part, or parts in reading order that together
+ *  make one vector. */
+type EmbedInput = EmbedPart | readonly EmbedPart[];
+/** What to load. Every field is optional; a missing one comes from the
+ *  model's DEFAULT, EmbeddingGemma 2 without `modelPath`. */
+interface EmbedderModel {
+  /** The safetensors weights of EmbeddingGemma 2 or all-MiniLM-L6-v2. The
+   *  model is read from the file. */
   readonly modelPath?: ModelPath;
-  /** The tokenizer JSON: a Hugging Face tokenizer.json or our compact asset. */
+  /** The vision tower's weights, for images and video. EmbeddingGemma 2
+   *  only. `null` skips it: a smaller download. */
+  readonly visionPath?: ModelPath | null;
+  /** The audio tower's weights, for audio. EmbeddingGemma 2 only. `null`
+   *  skips it: a smaller download. */
+  readonly audioPath?: ModelPath | null;
+  /** The Hugging Face tokenizer.json. */
   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
+   *  weights and activations, for half the memory traffic at a small cost
+   *  in precision. 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. */
+  /** Longest input in tokens. EmbeddingGemma 2: up to 2048, default 2048.
+   *  all-MiniLM-L6-v2: up to 512, default 256. Longer text is cut; a longer
+   *  input with images, video or audio is an error. */
   readonly maxTokens?: number;
-}
-interface TextEmbedder {
-  /** Length of every returned vector. */
+  /** Most tokens one image takes: 70, 140, 280, 560 or 1120. More tokens
+   *  keep more detail and take longer. Default 280. */
+  readonly imageTokens?: ImageTokenBudget;
+}
+/** Per-call options of embed() and embedBatch(). */
+interface EmbedOptions {
+  /** What the text is for. A search embeds its queries with `query` and
+   *  what it searches with `document`. all-MiniLM-L6-v2 ignores it.
+   *  Default: none. */
+  readonly task?: EmbeddingTask;
+  /** Length of the returned vectors: 768, 512, 256 or 128 for
+   *  EmbeddingGemma 2, 384 for all-MiniLM-L6-v2. A shorter vector keeps the
+   *  first values, made unit length again. Compare only vectors of the same
+   *  length. Default `dim`. */
+  readonly dims?: number;
+}
+/** The runner createEmbedder() returns. */
+interface Embedder {
+  /** Length of a vector without `dims`. */
   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[]>;
+  /** One input → unit-length vector. */
+  embed(input: EmbedInput, options?: EmbedOptions): Promise<Float32Array>;
+  /** Many inputs, one vector each. Much faster than embed() in a loop for
+   *  text. */
+  embedBatch(inputs: readonly EmbedInput[], options?: EmbedOptions): 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. */
+/** Cosine similarity of two unit-length vectors: 1 for the same meaning,
+ *  near 0 for unrelated inputs. */
 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>;
+/** Loads the model in `modelPath` with its tokenizer and towers, warms the
+ *  GPU, and returns the runner. With no config, loads EmbeddingGemma 2 from
+ *  the Hugging Face Hub. */
+export declare function createEmbedder(config?: EmbedderModel, opts?: LoadOptions): Promise<Embedder>;
 //#endregion
 //#region src/zoo/tasks/nlp/privacyFilter.d.ts
 /** What to load. With no config, the int8 export from the Hugging Face
@@ -334,7 +477,7 @@ interface SpeechToTextModel {
   readonly arch?: SpeechToTextArch;
   /** The safetensors checkpoint. */
   readonly modelPath?: ModelPath;
-  /** The tokenizer JSON: a Hugging Face tokenizer.json or our compact asset. */
+  /** The Hugging Face tokenizer.json. */
   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
@@ -385,29 +528,6 @@ export declare function decodeAudio(data: ArrayBuffer): Promise<Float32Array>;
  *  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;
@@ -614,11 +734,36 @@ interface DepthMap {
   readonly height: number;
   readonly data: Float32Array;
 }
+/** The model input as a GPU buffer: normalized RGB, `[channel][row][column]`
+ *  f32, `inputSize` wide and high. */
+type DepthInput = d.WgslArray<d.WgslArray<d.WgslArray<d.F32>>>;
+/** A depth map as a GPU buffer: `[row][column]` f32, `inputSize` wide and
+ *  high, the same values as DepthMap.data. */
+type DepthMapData = d.WgslArray<d.WgslArray<d.F32>>;
+interface EncodeEstimateDepthOptions extends EncodeOptions<GpuImage | GpuTensor<DepthInput>, GpuImageTarget | GpuTensor<DepthMapData>> {
+  /** Texture targets only. `minmax` maps each map to [0, 1], nearest = 0.
+   *  Default `none`: the raw values, which an unorm format clamps. */
+  readonly normalize?: 'none' | 'minmax';
+}
 interface DepthEstimator {
   /** Width and height of every returned map. */
   readonly inputSize: number;
+  /** Buffer layouts for encodeEstimateDepth, at this runner's size. Pass one
+   *  to `root.createBuffer` to make a buffer of the right type and size. */
+  readonly schemas: {
+    readonly input: DepthInput;
+    readonly output: DepthMapData;
+  };
   /** Image in, its depth map out. */
   estimateDepth(image: ImageBuffer): Promise<DepthMap>;
+  /** Records a depth estimate from GPU memory into GPU memory, with no CPU
+   *  copy. A texture source is fitted like an ImageBuffer; a buffer source
+   *  is the model input as-is. A texture target gets the map stretched to
+   *  its size in every channel; a buffer target gets the map's values.
+   *  Work submitted after it sees the result.
+   *  @throws RunntimeError `INVALID_ARGUMENT` for a resource of the wrong
+   *  format, usage or size. */
+  encodeEstimateDepth(options: EncodeEstimateDepthOptions): void;
   /** Frees the weights and every GPU buffer the runner holds. */
   dispose(): void;
 }
@@ -626,9 +771,7 @@ interface DepthEstimator {
 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.
- */
+/** CPU post-processing around the MobileNetV4 GPU forward. */
 interface Classification {
   classId: number;
   confidence: number;
@@ -668,4 +811,4 @@ interface ImageClassifier {
  *  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 };
+export { type BoundingBox, type BoxFormat, type BoxMap, type Classification, type ClassifyOptions, type CocoLandmark, type DepthEstimator, type DepthEstimatorModel, type DepthInput, type DepthMap, type DepthMapData, type DepthartVariant, type DetectKeypointsOptions, type DetectObjectsOptions, type EmbedInput, type EmbedOptions, type EmbedPart, type Embedder, type EmbedderModel, type EmbeddingTask, type EncodeEstimateDepthOptions, type EncodeOptions, type GpuEncoder, type GpuImage, type GpuImageTarget, type GpuTensor, type ImageBuffer, type ImageClassifier, type ImageClassifierModel, type ImageFormat, type ImageTokenBudget, 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 RunntimeErrorCode, type SegmentInstancesOptions, type Size, type SpeechStreamUpdate, type SpeechToText, type SpeechToTextArch, type SpeechToTextModel, type WeightCache, type Yolo26Variant, initRunntime };