@huggingface/transformers 4.0.0-next.5 → 4.0.0-next.7

package/dist/transformers.web.js

@@ -14,22 +14,32 @@ var node_path_default = {};
 var node_url_default = {};
 
 // src/env.js
-var VERSION = "4.0.0-next.5";
+var VERSION = "4.0.0-next.7";
+var HAS_SELF = typeof self !== "undefined";
 var IS_FS_AVAILABLE = !isEmpty(node_fs_default);
 var IS_PATH_AVAILABLE = !isEmpty(node_path_default);
-var IS_WEB_CACHE_AVAILABLE = typeof self !== "undefined" && "caches" in self;
+var IS_WEB_CACHE_AVAILABLE = HAS_SELF && "caches" in self;
 var IS_DENO_RUNTIME = typeof globalThis.Deno !== "undefined";
 var IS_BUN_RUNTIME = typeof globalThis.Bun !== "undefined";
 var IS_DENO_WEB_RUNTIME = IS_DENO_RUNTIME && IS_WEB_CACHE_AVAILABLE && !IS_FS_AVAILABLE;
 var IS_PROCESS_AVAILABLE = typeof process !== "undefined";
 var IS_NODE_ENV = IS_PROCESS_AVAILABLE && process?.release?.name === "node" && !IS_DENO_WEB_RUNTIME;
 var IS_BROWSER_ENV = typeof window !== "undefined" && typeof window.document !== "undefined";
-var IS_WEBWORKER_ENV = typeof self !== "undefined" && ["DedicatedWorkerGlobalScope", "ServiceWorkerGlobalScope", "SharedWorkerGlobalScope"].includes(
+var IS_WEBWORKER_ENV = HAS_SELF && ["DedicatedWorkerGlobalScope", "ServiceWorkerGlobalScope", "SharedWorkerGlobalScope"].includes(
   self.constructor?.name
 );
+var IS_WEB_ENV = IS_BROWSER_ENV || IS_WEBWORKER_ENV || IS_DENO_WEB_RUNTIME;
 var IS_WEBGPU_AVAILABLE = IS_NODE_ENV || typeof navigator !== "undefined" && "gpu" in navigator;
 var IS_WEBNN_AVAILABLE = typeof navigator !== "undefined" && "ml" in navigator;
 var IS_CRYPTO_AVAILABLE = typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function";
+var IS_CHROME_AVAILABLE = (
+  // @ts-ignore - chrome may not exist in all environments
+  typeof chrome !== "undefined" && typeof chrome.runtime !== "undefined" && typeof chrome.runtime.id === "string"
+);
+var IS_SERVICE_WORKER_ENV = (
+  // @ts-ignore - ServiceWorkerGlobalScope may not exist in all environments
+  typeof ServiceWorkerGlobalScope !== "undefined" && HAS_SELF && self instanceof ServiceWorkerGlobalScope
+);
 var isSafari = () => {
   if (typeof navigator === "undefined") {
     return false;
@@ -46,6 +56,12 @@ var apis = Object.freeze({
   IS_BROWSER_ENV,
   /** Whether we are running in a web worker environment */
   IS_WEBWORKER_ENV,
+  /** Whether we are running in a web-like environment (browser, web worker, or Deno web runtime) */
+  IS_WEB_ENV,
+  /** Whether we are running in a service worker environment */
+  IS_SERVICE_WORKER_ENV,
+  /** Whether we are running in Deno's web runtime (CDN imports, Cache API available, no filesystem) */
+  IS_DENO_WEB_RUNTIME,
   /** Whether the Cache API is available */
   IS_WEB_CACHE_AVAILABLE,
   /** Whether the WebGPU API is available */
@@ -63,7 +79,9 @@ var apis = Object.freeze({
   /** Whether the path API is available */
   IS_PATH_AVAILABLE,
   /** Whether the crypto API is available */
-  IS_CRYPTO_AVAILABLE
+  IS_CRYPTO_AVAILABLE,
+  /** Whether the Chrome runtime API is available */
+  IS_CHROME_AVAILABLE
 });
 var RUNNING_LOCALLY = IS_FS_AVAILABLE && IS_PATH_AVAILABLE;
 var dirname__ = "./";
@@ -124,6 +142,7 @@ var env = {
   customCache: null,
   useWasmCache: IS_WEB_CACHE_AVAILABLE || IS_FS_AVAILABLE,
   cacheKey: "transformers-cache",
+  experimental_useCrossOriginStorage: false,
   /////////////////// Custom fetch /////////////////////
   fetch: DEFAULT_FETCH
   //////////////////////////////////////////////////////
@@ -2674,7 +2693,7 @@ var Tokenizer = class {
 };
 var Tokenizer_default = Tokenizer;
 
-// ../../node_modules/.pnpm/@huggingface+jinja@0.5.5/node_modules/@huggingface/jinja/dist/index.js
+// ../../node_modules/.pnpm/@huggingface+jinja@0.5.6/node_modules/@huggingface/jinja/dist/index.js
 var TOKEN_TYPES = Object.freeze({
   Text: "Text",
   // The text between Jinja statements or expressions
@@ -4193,7 +4212,11 @@ var Environment = class {
     ["number", (operand) => operand instanceof IntegerValue || operand instanceof FloatValue],
     ["integer", (operand) => operand instanceof IntegerValue],
     ["iterable", (operand) => operand.type === "ArrayValue" || operand.type === "StringValue"],
-    ["mapping", (operand) => operand.type === "ObjectValue"],
+    ["mapping", (operand) => operand instanceof ObjectValue],
+    [
+      "sequence",
+      (operand) => operand instanceof ArrayValue || operand instanceof ObjectValue || operand instanceof StringValue
+    ],
     [
       "lower",
       (operand) => {
@@ -4466,6 +4489,9 @@ var Interpreter = class {
   applyFilter(operand, filterNode, environment) {
     if (filterNode.type === "Identifier") {
       const filter = filterNode;
+      if (filter.value === "safe") {
+        return operand;
+      }
       if (filter.value === "tojson") {
         return new StringValue(toJSON(operand, {}));
       }
@@ -4555,6 +4581,8 @@ var Interpreter = class {
             return new IntegerValue(Math.floor(operand.value));
           case "float":
             return new FloatValue(operand.value);
+          case "string":
+            return new StringValue(operand.toString());
           default:
             throw new Error(`Unknown NumericValue filter: ${filter.value}`);
         }
@@ -5508,7 +5536,7 @@ var Callable2 = (
   }
 );
 
-// src/utils/hub/files.js
+// src/utils/hub/FileResponse.js
 var CONTENT_TYPE_MAP = {
   txt: "text/plain",
   html: "text/html",
@@ -5619,6 +5647,170 @@ var FileResponse = class _FileResponse {
     return JSON.parse(await this.text());
   }
 };
+
+// src/utils/random.js
+var Random = class {
+  constructor(seed) {
+    this._mt = new Uint32Array(624);
+    this._idx = 625;
+    this._gauss_next = null;
+    this._random_fn = this.random.bind(this);
+    this.seed(seed);
+  }
+  /**
+   * Seeds this instance's PRNG.
+   *
+   * When called with a number, initializes the state deterministically from that value.
+   * When called with no arguments (or `undefined`/`null`), seeds from OS entropy
+   * via `crypto.getRandomValues`, matching Python's `random.seed()` behaviour.
+   *
+   * @param {number} [n] The seed value. Omit to seed from OS entropy.
+   */
+  seed(n) {
+    if (n === void 0 || n === null) {
+      if (apis.IS_CRYPTO_AVAILABLE) {
+        const buf = new Uint32Array(1);
+        crypto.getRandomValues(buf);
+        n = buf[0];
+      } else {
+        n = Date.now() >>> 0;
+      }
+    }
+    const mt = this._mt;
+    const u = (a, b) => Math.imul(a, b) >>> 0, key = [];
+    for (let v = n || 0; v > 0; v = Math.floor(v / 4294967296)) key.push(v & 4294967295);
+    if (!key.length) key.push(0);
+    mt[0] = 19650218;
+    for (let k = 1; k < 624; ++k) mt[k] = u(1812433253, mt[k - 1] ^ mt[k - 1] >>> 30) + k >>> 0;
+    let i = 1, j = 0;
+    for (let k = Math.max(624, key.length); k > 0; --k, ++i, ++j) {
+      if (i >= 624) {
+        mt[0] = mt[623];
+        i = 1;
+      }
+      if (j >= key.length) j = 0;
+      mt[i] = (mt[i] ^ u(mt[i - 1] ^ mt[i - 1] >>> 30, 1664525)) + key[j] + j >>> 0;
+    }
+    for (let k = 623; k > 0; --k, ++i) {
+      if (i >= 624) {
+        mt[0] = mt[623];
+        i = 1;
+      }
+      mt[i] = (mt[i] ^ u(mt[i - 1] ^ mt[i - 1] >>> 30, 1566083941)) - i >>> 0;
+    }
+    mt[0] = 2147483648;
+    this._idx = 624;
+    this._gauss_next = null;
+  }
+  /**
+   * Generates a random unsigned 32-bit integer.
+   *
+   * Performs the "twist" step when the state buffer is exhausted,
+   * then applies the standard MT19937 tempering transform.
+   *
+   * @returns {number} A random integer in the range [0, 2^32 - 1].
+   */
+  _int32() {
+    const mt = this._mt;
+    if (this._idx >= 624) {
+      for (let k = 0; k < 624; ++k) {
+        const y2 = mt[k] & 2147483648 | mt[(k + 1) % 624] & 2147483647;
+        mt[k] = (mt[(k + 397) % 624] ^ y2 >>> 1 ^ (y2 & 1 ? 2567483615 : 0)) >>> 0;
+      }
+      this._idx = 0;
+    }
+    let y = mt[this._idx++];
+    y ^= y >>> 11;
+    y ^= y << 7 & 2636928640;
+    y ^= y << 15 & 4022730752;
+    y ^= y >>> 18;
+    return y >>> 0;
+  }
+  /**
+   * Generates a random floating-point number in the half-open interval [0, 1).
+   *
+   * Combines two 32-bit integers (using 53 bits of precision) to produce
+   * a uniformly distributed double, matching Python's `random.random()`.
+   *
+   * @returns {number} A random float in [0, 1).
+   */
+  random() {
+    return ((this._int32() >>> 5) * 67108864 + (this._int32() >>> 6)) / 9007199254740992;
+  }
+  /**
+   * Generates a random number from a Gaussian (normal) distribution.
+   *
+   * Uses the Box-Muller transform with a cached spare value,
+   * matching Python's `random.gauss()` output for the same seed.
+   *
+   * @param {number} [mu=0] The mean of the distribution.
+   * @param {number} [sigma=1] The standard deviation of the distribution.
+   * @returns {number} A normally distributed random value.
+   */
+  gauss(mu = 0, sigma = 1) {
+    let z = this._gauss_next;
+    this._gauss_next = null;
+    if (z === null) {
+      const x2pi = this.random() * 2 * Math.PI, g2rad = Math.sqrt(-2 * Math.log(1 - this.random()));
+      z = Math.cos(x2pi) * g2rad;
+      this._gauss_next = Math.sin(x2pi) * g2rad;
+    }
+    return mu + z * sigma;
+  }
+  /**
+   * Shuffles an array in-place using the Fisher-Yates algorithm.
+   *
+   * Uses rejection sampling via `getrandbits`-style bit masking to ensure
+   * a uniform distribution, matching Python's `random.shuffle()`.
+   *
+   * @param {any[]} arr The array to shuffle in-place.
+   */
+  shuffle(arr) {
+    for (let i = arr.length - 1; i > 0; --i) {
+      const k = 32 - Math.clz32(i + 1);
+      let r = this._int32() >>> 32 - k;
+      while (r > i) r = this._int32() >>> 32 - k;
+      const t = arr[i];
+      arr[i] = arr[r];
+      arr[r] = t;
+    }
+  }
+  /**
+   * Selects a single element from a weighted population.
+   *
+   * Matches Python's `random.choices(population, weights=weights, k=1)[0]`
+   *
+   * @param {any[]} population The array of items to choose from.
+   * @param {number[]} weights An array of non-negative weights, one per population element.
+   * @returns {*} A single randomly selected element from the population.
+   */
+  choices(population, weights) {
+    return population[_weightedIndexWith(this._random_fn, weights)];
+  }
+};
+function _weightedIndexWith(randomFn, weights) {
+  let sum = 0;
+  for (let i = 0; i < weights.length; ++i) sum += weights[i];
+  let x = randomFn() * sum;
+  for (let i = 0; i < weights.length; ++i) {
+    x -= weights[i];
+    if (x < 0) return i;
+  }
+  return weights.length - 1;
+}
+var _default = new Random();
+var random = Object.freeze({
+  Random,
+  seed: _default.seed.bind(_default),
+  random: _default.random.bind(_default),
+  gauss: _default.gauss.bind(_default),
+  shuffle: _default.shuffle.bind(_default),
+  choices: _default.choices.bind(_default)
+});
+var _weightedIndex = (weights) => _weightedIndexWith(random.random, weights);
+
+// src/utils/cache/FileCache.js
+var rng = new Random();
 var FileCache = class {
   /**
    * Instantiate a `FileCache` object.
@@ -5650,13 +5842,16 @@ var FileCache = class {
    * @returns {Promise<void>}
    */
   async put(request, response, progress_callback = void 0) {
-    let filePath = node_path_default.join(this.path, request);
+    const filePath = node_path_default.join(this.path, request);
+    const id = apis.IS_PROCESS_AVAILABLE ? process.pid : Date.now();
+    const randomSuffix = rng._int32().toString(36);
+    const tmpPath = filePath + `.tmp.${id}.${randomSuffix}`;
     try {
       const contentLength = response.headers.get("Content-Length");
       const total = parseInt(contentLength ?? "0");
       let loaded = 0;
       await node_fs_default.promises.mkdir(node_path_default.dirname(filePath), { recursive: true });
-      const fileStream = node_fs_default.createWriteStream(filePath);
+      const fileStream = node_fs_default.createWriteStream(tmpPath);
       const reader = response.body.getReader();
       while (true) {
         const { done, value } = await reader.read();
@@ -5676,10 +5871,13 @@ var FileCache = class {
         const progress = total ? loaded / total * 100 : 0;
         progress_callback?.({ progress, loaded, total });
       }
-      fileStream.close();
+      await new Promise((resolve, reject) => {
+        fileStream.close((err) => err ? reject(err) : resolve());
+      });
+      await node_fs_default.promises.rename(tmpPath, filePath);
     } catch (error) {
       try {
-        await node_fs_default.promises.unlink(filePath);
+        await node_fs_default.promises.unlink(tmpPath);
       } catch {
       }
       throw error;
@@ -5702,6 +5900,7 @@ var FileCache = class {
   // TODO add the rest?
   // addAll(requests: RequestInfo[]): Promise<void>;
   // keys(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;
+  // match(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<Response | undefined>;
   // matchAll(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;
 };
 
@@ -5791,69 +5990,380 @@ async function readResponse(response, progress_callback, expectedSize) {
   await read();
   return buffer;
 }
-
-// src/utils/cache.js
-async function getCache(file_cache_dir = null) {
-  let cache = null;
-  if (env.useCustomCache) {
-    if (!env.customCache) {
-      throw Error("`env.useCustomCache=true`, but `env.customCache` is not defined.");
-    }
-    if (!env.customCache.match || !env.customCache.put) {
-      throw new Error(
-        "`env.customCache` must be an object which implements the `match` and `put` functions of the Web Cache API. For more information, see https://developer.mozilla.org/en-US/docs/Web/API/Cache"
-      );
-    }
-    cache = env.customCache;
+function isBlobURL(url) {
+  return isValidUrl(url, ["blob:"]);
+}
+function toAbsoluteURL(url) {
+  let baseURL;
+  if (typeof location !== "undefined" && location.href) {
+    baseURL = location.href;
+  } else if (typeof import.meta !== "undefined" && import.meta.url) {
+    baseURL = import.meta.url;
+  } else {
+    return url;
   }
-  if (!cache && env.useBrowserCache) {
-    if (typeof caches === "undefined") {
-      throw Error("Browser cache is not available in this environment.");
+  return new URL(url, baseURL).href;
+}
+
+// src/utils/cache/CrossOriginStorageCache.js
+var HASH_ALGORITHM = "SHA-256";
+var HASH_CACHE_NAME = "experimental_transformers-hash-cache";
+var makeHashDescriptor = (value) => ({ algorithm: HASH_ALGORITHM, value });
+var CrossOriginStorage = class {
+  /** @type {Promise<Cache> | null} */
+  #hashCache = null;
+  /**
+   * Returns (and lazily opens) the hash cache, reusing the same promise across concurrent callers.
+   * @returns {Promise<Cache>}
+   */
+  _getHashCache = () => {
+    this.#hashCache ??= caches.open(HASH_CACHE_NAME);
+    return this.#hashCache;
+  };
+  /**
+   * Returns whether the `navigator.crossOriginStorage` API is available in the current environment.
+   * @returns {boolean}
+   */
+  static isAvailable = () => typeof navigator !== "undefined" && "crossOriginStorage" in navigator;
+  /**
+   * Looks up a cached response for the given URL by resolving its SHA-256 hash and requesting
+   * the corresponding file handle from cross-origin storage.
+   *
+   * Implements `CacheInterface.match`.
+   *
+   * @param {string} request The URL of the resource to look up.
+   * @returns {Promise<Response|undefined>} The cached `Response`, or `undefined` if not found.
+   */
+  match = async (request) => {
+    const hashValue = await this._getFileHash(request);
+    if (!hashValue) {
+      return void 0;
     }
     try {
-      cache = await caches.open(env.cacheKey);
-    } catch (e) {
-      logger.warn("An error occurred while opening the browser cache:", e);
+      const [handle] = await navigator.crossOriginStorage.requestFileHandles([makeHashDescriptor(hashValue)]);
+      const blob = await handle.getFile();
+      return new Response(blob, {
+        headers: {
+          "Content-Length": String(blob.size)
+        }
+      });
+    } catch {
+      return void 0;
     }
-  }
-  if (!cache && env.useFSCache) {
-    if (!apis.IS_FS_AVAILABLE) {
-      throw Error("File System Cache is not available in this environment.");
+  };
+  /**
+   * Stores a response in cross-origin storage, keyed by its SHA-256 hash.
+   *
+   * For LFS-backed URLs the hash is resolved cheaply via `_getFileHash` (which checks
+   * `HASH_CACHE_NAME` first, then falls back to fetching the Git LFS pointer file)
+   * without reading the response body a second time.
+   *
+   * For non-LFS resources the hash is unknown upfront.  In that case the body is consumed
+   * in the background: the stream is read to compute the content hash, the file is written
+   * into cross-origin storage, and the computed hash is persisted to `HASH_CACHE_NAME`
+   * so that future `match` calls can resolve the file without a network round-trip.
+   *
+   * Implements `CacheInterface.put`.
+   *
+   * @param {string} request The URL of the resource (used as the hash-cache key).
+   * @param {Response} response The response whose body will be written to the cache.
+   * @returns {Promise<void>}
+   */
+  put = async (request, response) => {
+    const hashValue = await this._getFileHash(request);
+    if (hashValue) {
+      const blob = await response.blob();
+      await this._storeBlobInCOS(blob, hashValue);
+    } else {
+      this._processAndStore(request, response.body);
     }
-    cache = new FileCache(file_cache_dir ?? env.cacheDir);
-  }
-  return cache;
-}
-async function tryCache(cache, ...names) {
-  for (let name of names) {
+  };
+  /**
+   * Writes a blob into cross-origin storage using the given pre-computed hex hash string.
+   *
+   * @param {Blob} blob
+   * @param {string} hashHex Hex-encoded SHA-256 hash of `blob`.
+   * @returns {Promise<void>}
+   */
+  _storeBlobInCOS = async (blob, hashHex) => {
+    const [handle] = await navigator.crossOriginStorage.requestFileHandles([makeHashDescriptor(hashHex)], {
+      create: true
+    });
+    const writableStream = await handle.createWritable();
+    await writableStream.write(blob);
+    await writableStream.close();
+  };
+  /**
+   * Background task for non-LFS resources: consumes `stream`, computes the SHA-256 hash
+   * of the resulting blob, stores it in cross-origin storage, and persists the computed
+   * hash to `HASH_CACHE_NAME` keyed by `request` so future `match` calls can resolve the
+   * file without a network round-trip.
+   *
+   * Called fire-and-forget from `put` — errors are swallowed so failures never surface to
+   * the caller.
+   *
+   * @param {string} request The original resource URL.
+   * @param {ReadableStream} stream The response body stream to consume.
+   * @returns {Promise<void>}
+   */
+  _processAndStore = async (request, stream) => {
     try {
-      let result = await cache.match(name);
-      if (result) return result;
-    } catch (e) {
-      continue;
+      const chunks = [];
+      for await (const chunk2 of stream) {
+        chunks.push(chunk2);
+      }
+      const blob = new Blob(chunks);
+      const hashHex = await this._getBlobHash(blob);
+      await this._storeBlobInCOS(blob, hashHex);
+      try {
+        const hashCache = await this._getHashCache();
+        await hashCache.put(request, new Response(hashHex));
+      } catch {
+      }
+    } catch {
     }
-  }
-  return void 0;
-}
-
-// src/utils/model_registry/get_file_metadata.js
-async function fetch_file_head(urlOrPath) {
+  };
+  /**
+   * Deletes the cache entry for the given request.
+   *
+   * Removes the hash entry from `HASH_CACHE_NAME`. Note: cross-origin storage itself does not
+   * expose a delete API, so only the local hash mapping is removed. For non-LFS URLs this
+   * permanently prevents `match` from resolving the file. For LFS-backed URLs, `match` will
+   * re-fetch the LFS pointer file on the next call and repopulate the hash cache automatically.
+   *
+   * Implements `CacheInterface.delete`.
+   *
+   * @param {string} request
+   * @returns {Promise<boolean>} Resolves to `true` if the hash entry was deleted, `false` otherwise.
+   */
+  delete = async (request) => {
+    try {
+      const hashCache = await this._getHashCache();
+      return await hashCache.delete(request);
+    } catch {
+      return false;
+    }
+  };
+  /**
+   * Resolves the SHA-256 hash for a given URL.
+   *
+   * Returns the cached hash immediately if one has been persisted to `HASH_CACHE_NAME`.
+   * Otherwise falls back to `_getLfsFileHash` to retrieve the hash from the Hugging Face
+   * LFS pointer file, persisting the result to `HASH_CACHE_NAME` for future lookups.
+   *
+   * Returns `null` if the hash cannot be determined (e.g. non-LFS URL with no cached entry).
+   *
+   * @param {string} url The resource URL to resolve a hash for.
+   * @returns {Promise<string|null>} The hex-encoded SHA-256 hash, or `null` if unavailable.
+   */
+  _getFileHash = async (url) => {
+    try {
+      const hashCache = await this._getHashCache();
+      const cached = await hashCache.match(url);
+      if (cached) {
+        return cached.text();
+      }
+      const hash = await this._getLfsFileHash(url);
+      if (hash) {
+        await hashCache.put(url, new Response(hash));
+        return hash;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  };
+  /**
+   * Attempts to retrieve the SHA-256 hash for a Hugging Face resource URL from its raw
+   * Git LFS pointer file.
+   *
+   * Only applicable to URLs containing `/resolve/` (i.e. Hugging Face resolved file URLs).
+   * The `/resolve/` segment is rewritten to `/raw/` to fetch the LFS pointer directly.
+   * Returns `null` for non-LFS URLs or when the network request fails.
+   *
+   * @see https://huggingface.co/docs/hub/en/storage-backends#xet
+   * @param {string} url The resolved Hugging Face URL of the resource.
+   * @returns {Promise<string|null>} The hex-encoded SHA-256 hash, or `null` if unavailable.
+   */
+  _getLfsFileHash = async (url) => {
+    if (!url.includes("/resolve/")) {
+      return null;
+    }
+    const rawUrl = url.replace("/resolve/", "/raw/");
+    try {
+      const text = await fetch(rawUrl).then((r) => r.text());
+      const match = text.match(/^oid sha256:([0-9a-f]+)$/m);
+      return match ? match[1] : null;
+    } catch {
+      return null;
+    }
+  };
+  /**
+   * Computes the SHA-256 hash of a `Blob`'s contents.
+   *
+   * @param {Blob} blob The blob to hash.
+   * @returns {Promise<string>} The lowercase hex-encoded SHA-256 hash.
+   */
+  _getBlobHash = async (blob) => {
+    const arrayBuffer = await blob.arrayBuffer();
+    const hashBuffer = await crypto.subtle.digest(HASH_ALGORITHM, arrayBuffer);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  };
+};
+
+// src/utils/cache.js
+async function getCache(file_cache_dir = null) {
+  let cache2 = null;
+  if (env.useCustomCache) {
+    if (!env.customCache) {
+      throw Error("`env.useCustomCache=true`, but `env.customCache` is not defined.");
+    }
+    if (!env.customCache.match || !env.customCache.put) {
+      throw new Error(
+        "`env.customCache` must be an object which implements the `match` and `put` functions of the Web Cache API. For more information, see https://developer.mozilla.org/en-US/docs/Web/API/Cache"
+      );
+    }
+    cache2 = env.customCache;
+  }
+  if (!cache2 && env.experimental_useCrossOriginStorage && CrossOriginStorage.isAvailable()) {
+    cache2 = new CrossOriginStorage();
+  }
+  if (!cache2 && env.useBrowserCache) {
+    if (typeof caches === "undefined") {
+      throw Error("Browser cache is not available in this environment.");
+    }
+    try {
+      cache2 = await caches.open(env.cacheKey);
+    } catch (e) {
+      logger.warn("An error occurred while opening the browser cache:", e);
+    }
+  }
+  if (!cache2 && env.useFSCache) {
+    if (!apis.IS_FS_AVAILABLE) {
+      throw Error("File System Cache is not available in this environment.");
+    }
+    cache2 = new FileCache(file_cache_dir ?? env.cacheDir);
+  }
+  return cache2;
+}
+async function tryCache(cache2, ...names) {
+  for (let name of names) {
+    try {
+      let result = await cache2.match(name);
+      if (result) return result;
+    } catch (e) {
+      continue;
+    }
+  }
+  return void 0;
+}
+
+// src/utils/lru_cache.js
+var LRUCache2 = class {
+  /** @type {number} */
+  #capacity;
+  /** @type {Map<any, any>} */
+  #cache;
+  /**
+   * Creates an LRUCache instance.
+   * @param {number} capacity The maximum number of items the cache can hold.
+   */
+  constructor(capacity) {
+    this.#capacity = capacity;
+    this.#cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Retrieves the value associated with the given key and marks the key as recently used.
+   * @param {any} key The key to retrieve.
+   * @returns {any} The value associated with the key, or undefined if the key does not exist.
+   */
+  get(key) {
+    if (!this.#cache.has(key)) return void 0;
+    const value = this.#cache.get(key);
+    this.#cache.delete(key);
+    this.#cache.set(key, value);
+    return value;
+  }
+  /**
+   * Inserts or updates the key-value pair in the cache.
+   * If the key already exists, it is updated and marked as recently used.
+   * If the cache exceeds its capacity, the least recently used item is evicted.
+   * @param {any} key The key to add or update.
+   * @param {any} value The value to associate with the key.
+   */
+  put(key, value) {
+    if (this.#cache.has(key)) {
+      this.#cache.delete(key);
+    }
+    this.#cache.set(key, value);
+    if (this.#cache.size > this.#capacity) {
+      this.#cache.delete(this.#cache.keys().next().value);
+    }
+  }
+  /**
+   * Removes the entry for the given key from the cache.
+   * @param {any} key The key to delete.
+   * @returns {boolean} `true` if the entry existed and was removed, `false` otherwise.
+   */
+  delete(key) {
+    return this.#cache.delete(key);
+  }
+  /**
+   * Clears the cache.
+   */
+  clear() {
+    this.#cache.clear();
+  }
+};
+
+// src/utils/memoize_promise.js
+var MAX_CACHE_SIZE = 100;
+var cache = new LRUCache2(MAX_CACHE_SIZE);
+function memoizePromise(key, factory) {
+  const cached = cache.get(key);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const promise = factory().then(
+    (value) => value,
+    (err) => {
+      cache.delete(key);
+      return Promise.reject(err);
+    }
+  );
+  cache.put(key, promise);
+  return promise;
+}
+
+// src/utils/model_registry/get_file_metadata.js
+async function fetch_file_head(urlOrPath) {
   if (!isValidUrl(urlOrPath, ["http:", "https:"])) {
     return null;
   }
   const headers = getFetchHeaders(urlOrPath);
   headers.set("Range", "bytes=0-0");
-  return env.fetch(urlOrPath, { method: "GET", headers });
+  return env.fetch(urlOrPath, { method: "GET", headers, cache: "no-store" });
+}
+function get_file_metadata(path_or_repo_id, filename, options = {}) {
+  const key = JSON.stringify([
+    path_or_repo_id,
+    filename,
+    options?.revision,
+    options?.cache_dir,
+    options?.local_files_only
+  ]);
+  return memoizePromise(key, () => _get_file_metadata(path_or_repo_id, filename, options));
 }
-async function get_file_metadata(path_or_repo_id, filename, options = {}) {
-  const cache = await getCache(options?.cache_dir);
+async function _get_file_metadata(path_or_repo_id, filename, options) {
+  const cache2 = await getCache(options?.cache_dir);
   const { localPath, remoteURL, proposedCacheKey, validModelId } = buildResourcePaths(
     path_or_repo_id,
     filename,
     options,
-    cache
+    cache2
   );
-  const cachedResponse = await checkCachedResource(cache, localPath, proposedCacheKey);
+  const cachedResponse = await checkCachedResource(cache2, localPath, proposedCacheKey);
   if (cachedResponse !== void 0 && typeof cachedResponse !== "string") {
     const size = cachedResponse.headers.get("content-length");
     const contentType = cachedResponse.headers.get("content-type");
@@ -5951,7 +6461,7 @@ function getFetchHeaders(urlOrPath) {
   }
   return headers;
 }
-function buildResourcePaths(path_or_repo_id, filename, options = {}, cache = null) {
+function buildResourcePaths(path_or_repo_id, filename, options = {}, cache2 = null) {
   const revision = options.revision ?? "main";
   const requestURL = pathJoin(path_or_repo_id, filename);
   const validModelId = isValidHfModelId(path_or_repo_id);
@@ -5961,7 +6471,7 @@ function buildResourcePaths(path_or_repo_id, filename, options = {}, cache = nul
     env.remotePathTemplate.replaceAll("{model}", path_or_repo_id).replaceAll("{revision}", encodeURIComponent(revision)),
     filename
   );
-  const proposedCacheKey = cache instanceof FileCache ? (
+  const proposedCacheKey = cache2 instanceof FileCache ? (
     // Choose cache key for filesystem cache
     // When using the main revision (default), we use the request URL as the cache key.
     // If a specific revision is requested, we account for this in the cache key.
@@ -5975,14 +6485,14 @@ function buildResourcePaths(path_or_repo_id, filename, options = {}, cache = nul
     validModelId
   };
 }
-async function checkCachedResource(cache, localPath, proposedCacheKey) {
-  if (!cache) {
+async function checkCachedResource(cache2, localPath, proposedCacheKey) {
+  if (!cache2) {
     return void 0;
   }
-  return await tryCache(cache, localPath, proposedCacheKey);
+  return await tryCache(cache2, localPath, proposedCacheKey);
 }
-async function storeCachedResource(path_or_repo_id, filename, cache, cacheKey, response, result, options = {}) {
-  if (await cache.match(cacheKey) !== void 0) {
+async function storeCachedResource(path_or_repo_id, filename, cache2, cacheKey, response, result, options = {}) {
+  if (await cache2.match(cacheKey) !== void 0) {
     return;
   }
   if (!result) {
@@ -5992,14 +6502,14 @@ async function storeCachedResource(path_or_repo_id, filename, cache, cacheKey, r
       file: filename,
       ...data
     }) : void 0;
-    await cache.put(
+    await cache2.put(
       cacheKey,
       /** @type {Response} */
       response,
       wrapped_progress
     );
   } else if (typeof response !== "string") {
-    await cache.put(
+    await cache2.put(
       cacheKey,
       new Response(
         /** @type {any} */
@@ -6013,17 +6523,17 @@ async function storeCachedResource(path_or_repo_id, filename, cache, cacheKey, r
     });
   }
 }
-async function loadResourceFile(path_or_repo_id, filename, fatal = true, options = {}, return_path = false, cache = null) {
+async function loadResourceFile(path_or_repo_id, filename, fatal = true, options = {}, return_path = false, cache2 = null) {
   const { requestURL, localPath, remoteURL, proposedCacheKey, validModelId } = buildResourcePaths(
     path_or_repo_id,
     filename,
     options,
-    cache
+    cache2
   );
   let cacheKey;
   let toCacheResponse = false;
   let response;
-  response = await checkCachedResource(cache, localPath, proposedCacheKey);
+  response = await checkCachedResource(cache2, localPath, proposedCacheKey);
   const cacheHit = response !== void 0;
   if (!cacheHit) {
     if (env.allowLocalModels) {
@@ -6064,7 +6574,7 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
       }
       cacheKey = proposedCacheKey;
     }
-    toCacheResponse = cache && // 1. A caching system is available
+    toCacheResponse = cache2 && // 1. A caching system is available
     typeof Response !== "undefined" && // 2. `Response` is defined (i.e., we are in a browser-like environment)
     response instanceof Response && // 3. result is a `Response` object (i.e., not a `FileResponse`)
     response.status === 200;
@@ -6126,7 +6636,7 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
     // i.e., do not cache FileResponses (prevents duplication)
     toCacheResponse && cacheKey && typeof response !== "string"
   ) {
-    await storeCachedResource(path_or_repo_id, filename, cache, cacheKey, response, result, options);
+    await storeCachedResource(path_or_repo_id, filename, cache2, cacheKey, response, result, options);
   }
   dispatchCallback(options.progress_callback, {
     status: "done",
@@ -6142,7 +6652,7 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
   if (response instanceof FileResponse) {
     return response.filePath;
   }
-  const cachedResponse = await cache?.match(cacheKey);
+  const cachedResponse = await cache2?.match(cacheKey);
   if (cachedResponse instanceof FileResponse) {
     return cachedResponse.filePath;
   } else if (cachedResponse instanceof Response) {
@@ -6169,8 +6679,8 @@ async function getModelFile(path_or_repo_id, filename, fatal = true, options = {
     name: path_or_repo_id,
     file: filename
   });
-  const cache = await getCache(options?.cache_dir);
-  return await loadResourceFile(path_or_repo_id, filename, fatal, options, return_path, cache);
+  const cache2 = await getCache(options?.cache_dir);
+  return await loadResourceFile(path_or_repo_id, filename, fatal, options, return_path, cache2);
 }
 async function getModelText(modelPath, fileName, fatal = true, options = {}) {
   const buffer = await getModelFile(modelPath, fileName, fatal, options, false);
@@ -6973,11 +7483,11 @@ import * as ONNX_WEB from "onnxruntime-web/webgpu";
 // src/backends/utils/cacheWasm.js
 async function loadAndCacheFile(url) {
   const fileName = url.split("/").pop();
-  let cache;
+  let cache2;
   try {
-    cache = await getCache();
-    if (cache) {
-      const result = await cache.match(url);
+    cache2 = await getCache();
+    if (cache2) {
+      const result = await cache2.match(url);
       if (result) {
         return result;
       }
@@ -6989,9 +7499,9 @@ async function loadAndCacheFile(url) {
   if (!response.ok) {
     throw new Error(`Failed to fetch ${fileName}: ${response.status} ${response.statusText}`);
   }
-  if (cache) {
+  if (cache2) {
     try {
-      await cache.put(url, response.clone());
+      await cache2.put(url, response.clone());
     } catch (e) {
       logger.warn(`Failed to cache ${fileName}:`, e);
     }
@@ -7009,34 +7519,21 @@ async function loadWasmBinary(wasmURL) {
   }
 }
 async function loadWasmFactory(libURL) {
+  if (apis.IS_SERVICE_WORKER_ENV || apis.IS_CHROME_AVAILABLE) {
+    return libURL;
+  }
   const response = await loadAndCacheFile(libURL);
   if (!response || typeof response === "string") return null;
   try {
     let code = await response.text();
-    const baseUrl = libURL.split("/").slice(0, -1).join("/");
-    code = code.replaceAll("import.meta.url", `"${baseUrl}"`);
     code = code.replaceAll("globalThis.process?.versions?.node", "false");
     const blob = new Blob([code], { type: "text/javascript" });
     return URL.createObjectURL(blob);
   } catch (error) {
-    logger.warn("Failed to read WASM binary:", error);
+    logger.warn("Failed to read WASM factory:", error);
     return null;
   }
 }
-function isBlobURL(url) {
-  return isValidUrl(url, ["blob:"]);
-}
-function toAbsoluteURL(url) {
-  let baseURL;
-  if (typeof location !== "undefined" && location.href) {
-    baseURL = location.href;
-  } else if (typeof import.meta !== "undefined" && import.meta.url) {
-    baseURL = import.meta.url;
-  } else {
-    return url;
-  }
-  return new URL(url, baseURL).href;
-}
 
 // src/backends/onnx.js
 import { Tensor } from "onnxruntime-common";
@@ -7135,7 +7632,6 @@ function deviceToExecutionProviders(device = null) {
   }
   throw new Error(`Unsupported device: "${device}". Should be one of: ${supportedDevices.join(", ")}.`);
 }
-var IS_WEB_ENV = apis.IS_BROWSER_ENV || apis.IS_WEBWORKER_ENV;
 var webInitChain = Promise.resolve();
 var wasmLoadPromise = null;
 async function ensureWasmLoaded() {
@@ -7144,6 +7640,11 @@ async function ensureWasmLoaded() {
   }
   const shouldUseWasmCache = env.useWasmCache && typeof ONNX_ENV?.wasm?.wasmPaths === "object" && ONNX_ENV?.wasm?.wasmPaths?.wasm && ONNX_ENV?.wasm?.wasmPaths?.mjs;
   if (!shouldUseWasmCache) {
+    if (apis.IS_DENO_WEB_RUNTIME) {
+      throw new Error(
+        "env.useWasmCache=false is not supported in Deno's web runtime. Remove the useWasmCache override."
+      );
+    }
     wasmLoadPromise = Promise.resolve();
     return wasmLoadPromise;
   }
@@ -7152,6 +7653,7 @@ async function ensureWasmLoaded() {
       /** @type {{ wasm: string, mjs: string }} */
       ONNX_ENV.wasm.wasmPaths
     );
+    let wasmBinaryLoaded = false;
     await Promise.all([
       // Load and cache the WASM binary
       urls.wasm && !isBlobURL(urls.wasm) ? (async () => {
@@ -7159,12 +7661,13 @@ async function ensureWasmLoaded() {
           const wasmBinary = await loadWasmBinary(toAbsoluteURL(urls.wasm));
           if (wasmBinary) {
             ONNX_ENV.wasm.wasmBinary = wasmBinary;
+            wasmBinaryLoaded = true;
           }
         } catch (err) {
           logger.warn("Failed to pre-load WASM binary:", err);
         }
       })() : Promise.resolve(),
-      // Load and cache the WASM factory
+      // Load and cache the WASM factory as a blob URL
       urls.mjs && !isBlobURL(urls.mjs) ? (async () => {
         try {
           const wasmFactoryBlob = await loadWasmFactory(toAbsoluteURL(urls.mjs));
@@ -7176,6 +7679,9 @@ async function ensureWasmLoaded() {
         }
       })() : Promise.resolve()
     ]);
+    if (!wasmBinaryLoaded) {
+      ONNX_ENV.wasm.wasmPaths.mjs = urls.mjs;
+    }
   })();
   return wasmLoadPromise;
 }
@@ -7187,51 +7693,52 @@ async function createInferenceSession(buffer_or_path, session_options, session_c
     logSeverityLevel,
     ...session_options
   });
-  const session = await (IS_WEB_ENV ? webInitChain = webInitChain.then(load) : load());
+  const session = await (apis.IS_WEB_ENV ? webInitChain = webInitChain.then(load) : load());
   session.config = session_config;
   return session;
 }
 var webInferenceChain = Promise.resolve();
 async function runInferenceSession(session, ortFeed) {
   const run = () => session.run(ortFeed);
-  const output = await (IS_WEB_ENV ? webInferenceChain = webInferenceChain.then(run) : run());
-  return output;
+  return apis.IS_WEB_ENV ? webInferenceChain = webInferenceChain.then(run) : run();
 }
 function isONNXTensor(x) {
   return x instanceof ONNX.Tensor;
 }
 var ONNX_ENV = ONNX?.env;
-if (ONNX_ENV?.wasm) {
-  if (
-    // @ts-ignore Cannot find name 'ServiceWorkerGlobalScope'.ts(2304)
-    !(typeof ServiceWorkerGlobalScope !== "undefined" && self instanceof ServiceWorkerGlobalScope) && ONNX_ENV.versions?.web && !ONNX_ENV.wasm.wasmPaths
-  ) {
-    const wasmPathPrefix = `https://cdn.jsdelivr.net/npm/onnxruntime-web@${ONNX_ENV.versions.web}/dist/`;
-    ONNX_ENV.wasm.wasmPaths = apis.IS_SAFARI ? {
-      mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.mjs`,
-      wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.wasm`
-    } : {
-      mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.mjs`,
-      wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.wasm`
-    };
-  }
-  ONNX_ENV.wasm.proxy = false;
-}
-if (ONNX_ENV?.webgpu) {
-  ONNX_ENV.webgpu.powerPreference = "high-performance";
-}
 function isONNXProxy() {
   return ONNX_ENV?.wasm?.proxy;
 }
-function setLogLevel(logLevel2) {
-  const severityLevel = getOnnxLogSeverityLevel(logLevel2);
-  ONNX_ENV.logLevel = ONNX_LOG_LEVEL_NAMES[severityLevel];
+if (ONNX_ENV) {
+  let setLogLevel = function(logLevel2) {
+    const severityLevel = getOnnxLogSeverityLevel(logLevel2);
+    ONNX_ENV.logLevel = ONNX_LOG_LEVEL_NAMES[severityLevel];
+  };
+  if (ONNX_ENV.wasm) {
+    if (
+      // @ts-ignore Cannot find name 'ServiceWorkerGlobalScope'.ts(2304)
+      !(typeof ServiceWorkerGlobalScope !== "undefined" && self instanceof ServiceWorkerGlobalScope) && ONNX_ENV.versions?.web && !ONNX_ENV.wasm.wasmPaths
+    ) {
+      const wasmPathPrefix = `https://cdn.jsdelivr.net/npm/onnxruntime-web@${ONNX_ENV.versions.web}/dist/`;
+      ONNX_ENV.wasm.wasmPaths = apis.IS_SAFARI ? {
+        mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.mjs`,
+        wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.wasm`
+      } : {
+        mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.mjs`,
+        wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.wasm`
+      };
+    }
+    ONNX_ENV.wasm.proxy = false;
+  }
+  if (ONNX_ENV.webgpu) {
+    ONNX_ENV.webgpu.powerPreference = "high-performance";
+  }
+  setLogLevel(env.logLevel ?? LogLevel.WARNING);
+  env.backends.onnx = {
+    ...ONNX_ENV,
+    setLogLevel
+  };
 }
-setLogLevel(env.logLevel ?? LogLevel.WARNING);
-env.backends.onnx = {
-  ...ONNX_ENV,
-  setLogLevel
-};
 
 // src/ops/registry.js
 var wrap = async (session_bytes, session_options, names) => {
@@ -8423,179 +8930,18 @@ var DataTypeMap = Object.freeze({
   float64: Float64Array,
   string: Array,
   // string[]
-  int8: Int8Array,
-  uint8: Uint8Array,
-  int16: Int16Array,
-  uint16: Uint16Array,
-  int32: Int32Array,
-  uint32: Uint32Array,
-  int64: BigInt64Array,
-  uint64: BigUint64Array,
-  bool: Uint8Array,
-  uint4: Uint8Array,
-  int4: Int8Array
-});
-
-// src/utils/random.js
-var Random = class {
-  constructor(seed) {
-    this._mt = new Uint32Array(624);
-    this._idx = 625;
-    this._gauss_next = null;
-    this._random_fn = this.random.bind(this);
-    this.seed(seed);
-  }
-  /**
-   * Seeds this instance's PRNG.
-   *
-   * When called with a number, initializes the state deterministically from that value.
-   * When called with no arguments (or `undefined`/`null`), seeds from OS entropy
-   * via `crypto.getRandomValues`, matching Python's `random.seed()` behaviour.
-   *
-   * @param {number} [n] The seed value. Omit to seed from OS entropy.
-   */
-  seed(n) {
-    if (n === void 0 || n === null) {
-      if (apis.IS_CRYPTO_AVAILABLE) {
-        const buf = new Uint32Array(1);
-        crypto.getRandomValues(buf);
-        n = buf[0];
-      } else {
-        n = Date.now() >>> 0;
-      }
-    }
-    const mt = this._mt;
-    const u = (a, b) => Math.imul(a, b) >>> 0, key = [];
-    for (let v = n || 0; v > 0; v = Math.floor(v / 4294967296)) key.push(v & 4294967295);
-    if (!key.length) key.push(0);
-    mt[0] = 19650218;
-    for (let k = 1; k < 624; ++k) mt[k] = u(1812433253, mt[k - 1] ^ mt[k - 1] >>> 30) + k >>> 0;
-    let i = 1, j = 0;
-    for (let k = Math.max(624, key.length); k > 0; --k, ++i, ++j) {
-      if (i >= 624) {
-        mt[0] = mt[623];
-        i = 1;
-      }
-      if (j >= key.length) j = 0;
-      mt[i] = (mt[i] ^ u(mt[i - 1] ^ mt[i - 1] >>> 30, 1664525)) + key[j] + j >>> 0;
-    }
-    for (let k = 623; k > 0; --k, ++i) {
-      if (i >= 624) {
-        mt[0] = mt[623];
-        i = 1;
-      }
-      mt[i] = (mt[i] ^ u(mt[i - 1] ^ mt[i - 1] >>> 30, 1566083941)) - i >>> 0;
-    }
-    mt[0] = 2147483648;
-    this._idx = 624;
-    this._gauss_next = null;
-  }
-  /**
-   * Generates a random unsigned 32-bit integer.
-   *
-   * Performs the "twist" step when the state buffer is exhausted,
-   * then applies the standard MT19937 tempering transform.
-   *
-   * @returns {number} A random integer in the range [0, 2^32 - 1].
-   */
-  _int32() {
-    const mt = this._mt;
-    if (this._idx >= 624) {
-      for (let k = 0; k < 624; ++k) {
-        const y2 = mt[k] & 2147483648 | mt[(k + 1) % 624] & 2147483647;
-        mt[k] = (mt[(k + 397) % 624] ^ y2 >>> 1 ^ (y2 & 1 ? 2567483615 : 0)) >>> 0;
-      }
-      this._idx = 0;
-    }
-    let y = mt[this._idx++];
-    y ^= y >>> 11;
-    y ^= y << 7 & 2636928640;
-    y ^= y << 15 & 4022730752;
-    y ^= y >>> 18;
-    return y >>> 0;
-  }
-  /**
-   * Generates a random floating-point number in the half-open interval [0, 1).
-   *
-   * Combines two 32-bit integers (using 53 bits of precision) to produce
-   * a uniformly distributed double, matching Python's `random.random()`.
-   *
-   * @returns {number} A random float in [0, 1).
-   */
-  random() {
-    return ((this._int32() >>> 5) * 67108864 + (this._int32() >>> 6)) / 9007199254740992;
-  }
-  /**
-   * Generates a random number from a Gaussian (normal) distribution.
-   *
-   * Uses the Box-Muller transform with a cached spare value,
-   * matching Python's `random.gauss()` output for the same seed.
-   *
-   * @param {number} [mu=0] The mean of the distribution.
-   * @param {number} [sigma=1] The standard deviation of the distribution.
-   * @returns {number} A normally distributed random value.
-   */
-  gauss(mu = 0, sigma = 1) {
-    let z = this._gauss_next;
-    this._gauss_next = null;
-    if (z === null) {
-      const x2pi = this.random() * 2 * Math.PI, g2rad = Math.sqrt(-2 * Math.log(1 - this.random()));
-      z = Math.cos(x2pi) * g2rad;
-      this._gauss_next = Math.sin(x2pi) * g2rad;
-    }
-    return mu + z * sigma;
-  }
-  /**
-   * Shuffles an array in-place using the Fisher-Yates algorithm.
-   *
-   * Uses rejection sampling via `getrandbits`-style bit masking to ensure
-   * a uniform distribution, matching Python's `random.shuffle()`.
-   *
-   * @param {any[]} arr The array to shuffle in-place.
-   */
-  shuffle(arr) {
-    for (let i = arr.length - 1; i > 0; --i) {
-      const k = 32 - Math.clz32(i + 1);
-      let r = this._int32() >>> 32 - k;
-      while (r > i) r = this._int32() >>> 32 - k;
-      const t = arr[i];
-      arr[i] = arr[r];
-      arr[r] = t;
-    }
-  }
-  /**
-   * Selects a single element from a weighted population.
-   *
-   * Matches Python's `random.choices(population, weights=weights, k=1)[0]`
-   *
-   * @param {any[]} population The array of items to choose from.
-   * @param {number[]} weights An array of non-negative weights, one per population element.
-   * @returns {*} A single randomly selected element from the population.
-   */
-  choices(population, weights) {
-    return population[_weightedIndexWith(this._random_fn, weights)];
-  }
-};
-function _weightedIndexWith(randomFn, weights) {
-  let sum = 0;
-  for (let i = 0; i < weights.length; ++i) sum += weights[i];
-  let x = randomFn() * sum;
-  for (let i = 0; i < weights.length; ++i) {
-    x -= weights[i];
-    if (x < 0) return i;
-  }
-  return weights.length - 1;
-}
-var _default = new Random();
-var random = Object.freeze({
-  Random,
-  seed: _default.seed.bind(_default),
-  random: _default.random.bind(_default),
-  gauss: _default.gauss.bind(_default),
-  shuffle: _default.shuffle.bind(_default),
-  choices: _default.choices.bind(_default)
+  int8: Int8Array,
+  uint8: Uint8Array,
+  int16: Int16Array,
+  uint16: Uint16Array,
+  int32: Int32Array,
+  uint32: Uint32Array,
+  int64: BigInt64Array,
+  uint64: BigUint64Array,
+  bool: Uint8Array,
+  uint4: Uint8Array,
+  int4: Int8Array
 });
-var _weightedIndex = (weights) => _weightedIndexWith(random.random, weights);
 
 // src/utils/tensor.js
 var Tensor2 = class _Tensor {
@@ -9007,9 +9353,23 @@ var Tensor2 = class _Tensor {
       throw Error(`Unsupported norm: ${p}`);
     }
     const this_data = this.data;
-    const fn = (a, b) => a + b ** p;
+    const is_bigint = this_data instanceof BigInt64Array || this_data instanceof BigUint64Array;
+    if (is_bigint && p !== 1) {
+      throw Error(`Expected a floating point tensor as input. Got ${this.type}`);
+    }
+    let fn, zero;
+    if (is_bigint) {
+      fn = (a, b) => a + b;
+      zero = 0n;
+    } else {
+      fn = (a, b) => a + b ** p;
+      zero = 0;
+    }
     if (dim === null) {
-      const val = this_data.reduce(fn, 0) ** (1 / p);
+      let val = this_data.reduce(fn, zero);
+      if (p !== 1) {
+        val = val ** (1 / p);
+      }
       return new _Tensor(this.type, [val], []);
     }
     const [type, result, resultDims] = reduce_helper(fn, this, dim, keepdim);
@@ -11469,9 +11829,11 @@ __export(processors_exports, {
   ChatterboxProcessor: () => ChatterboxProcessor,
   Florence2Processor: () => Florence2Processor,
   Gemma3nProcessor: () => Gemma3nProcessor,
+  GraniteSpeechProcessor: () => GraniteSpeechProcessor,
   GroundingDinoProcessor: () => GroundingDinoProcessor,
   Idefics3Processor: () => Idefics3Processor,
   JinaCLIPProcessor: () => JinaCLIPProcessor,
+  Lfm2VlProcessor: () => Lfm2VlProcessor,
   LlavaProcessor: () => LlavaProcessor,
   MgpstrProcessor: () => MgpstrProcessor,
   MoonshineProcessor: () => MoonshineProcessor,
@@ -11492,6 +11854,7 @@ __export(processors_exports, {
   UltravoxProcessor: () => UltravoxProcessor,
   VLChatProcessor: () => VLChatProcessor,
   VoxtralProcessor: () => VoxtralProcessor,
+  VoxtralRealtimeProcessor: () => VoxtralRealtimeProcessor,
   Wav2Vec2Processor: () => Wav2Vec2Processor,
   Wav2Vec2ProcessorWithLM: () => Wav2Vec2ProcessorWithLM,
   WhisperProcessor: () => WhisperProcessor
@@ -11546,12 +11909,14 @@ __export(feature_extractors_exports, {
   EncodecFeatureExtractor: () => EncodecFeatureExtractor,
   FeatureExtractor: () => FeatureExtractor,
   Gemma3nAudioFeatureExtractor: () => Gemma3nAudioFeatureExtractor,
+  GraniteSpeechFeatureExtractor: () => GraniteSpeechFeatureExtractor,
   MoonshineFeatureExtractor: () => MoonshineFeatureExtractor,
   ParakeetFeatureExtractor: () => ParakeetFeatureExtractor,
   PyAnnoteFeatureExtractor: () => PyAnnoteFeatureExtractor,
   SeamlessM4TFeatureExtractor: () => SeamlessM4TFeatureExtractor,
   SnacFeatureExtractor: () => SnacFeatureExtractor,
   SpeechT5FeatureExtractor: () => SpeechT5FeatureExtractor,
+  VoxtralRealtimeFeatureExtractor: () => VoxtralRealtimeFeatureExtractor,
   Wav2Vec2FeatureExtractor: () => Wav2Vec2FeatureExtractor,
   WeSpeakerFeatureExtractor: () => WeSpeakerFeatureExtractor,
   WhisperFeatureExtractor: () => WhisperFeatureExtractor
@@ -11786,6 +12151,7 @@ async function spectrogram(waveform, window2, frame_length, hop_length, {
   mel_filters = null,
   mel_floor = 1e-10,
   log_mel = null,
+  max_log_mel = null,
   reference = 1,
   min_value = 1e-10,
   db_range = null,
@@ -11925,6 +12291,17 @@ async function spectrogram(waveform, window2, frame_length, hop_length, {
           mel_spec_data[i] = Math.log10(mel_spec_data[i]);
         }
         break;
+      case "log10_max_norm": {
+        for (let i = 0; i < o; ++i) {
+          mel_spec_data[i] = Math.log10(mel_spec_data[i]);
+        }
+        const logMax = max_log_mel ?? max(mel_spec_data)[0];
+        const threshold = logMax - 8;
+        for (let i = 0; i < o; ++i) {
+          mel_spec_data[i] = (Math.max(mel_spec_data[i], threshold) + 4) / 4;
+        }
+        break;
+      }
       case "dB":
         if (power === 1) {
           amplitude_to_db(mel_spec_data, reference, min_value, db_range);
@@ -11935,7 +12312,9 @@ async function spectrogram(waveform, window2, frame_length, hop_length, {
         }
         break;
       default:
-        throw new Error(`log_mel must be one of null, 'log', 'log10' or 'dB'. Got '${log_mel}'`);
+        throw new Error(
+          `log_mel must be one of null, 'log', 'log10', 'log10_max_norm', or 'dB'. Got '${log_mel}'`
+        );
     }
   }
   return mel_spec;
@@ -12440,6 +12819,56 @@ var Gemma3nAudioFeatureExtractor = class extends FeatureExtractor {
   }
 };
 
+// src/models/granite_speech/feature_extraction_granite_speech.js
+var GraniteSpeechFeatureExtractor = class extends FeatureExtractor {
+  constructor(config) {
+    super(config);
+    const { n_fft, win_length, n_mels, sample_rate } = config.melspec_kwargs;
+    this.mel_filters = mel_filter_bank(
+      Math.floor(1 + n_fft / 2),
+      // num_frequency_bins = 257
+      n_mels,
+      // 80
+      0,
+      // min_frequency
+      sample_rate / 2,
+      // max_frequency = 8000
+      sample_rate,
+      // 16000
+      null,
+      // norm (torchaudio default: no norm)
+      "htk"
+      // mel_scale (torchaudio default)
+    );
+    const raw_window = window_function(win_length, "hann");
+    this.window = new Float64Array(n_fft);
+    const pad = Math.floor((n_fft - win_length) / 2);
+    this.window.set(raw_window, pad);
+  }
+  /**
+   * Extract mel spectrogram features from audio, matching the Python GraniteSpeechFeatureExtractor.
+   * @param {Float32Array|Float64Array} audio The audio waveform.
+   * @returns {Promise<{input_features: Tensor}>}
+   */
+  async _call(audio) {
+    validate_audio_inputs(audio, "GraniteSpeechFeatureExtractor");
+    const { n_fft, hop_length, n_mels } = this.config.melspec_kwargs;
+    const num_frames = 1 + Math.floor((audio.length - 1) / hop_length);
+    const max_num_frames = num_frames - num_frames % 2;
+    const mel = await spectrogram(audio, this.window, n_fft, hop_length, {
+      power: 2,
+      mel_filters: this.mel_filters,
+      log_mel: "log10_max_norm",
+      transpose: true,
+      // [time, n_mels]
+      max_num_frames,
+      do_pad: false
+    });
+    const input_features = mel.view(-1, 2 * n_mels).unsqueeze_(0);
+    return { input_features };
+  }
+};
+
 // src/models/moonshine/feature_extraction_moonshine.js
 var MoonshineFeatureExtractor = class extends FeatureExtractor {
   /**
@@ -12920,6 +13349,71 @@ var WeSpeakerFeatureExtractor = class extends FeatureExtractor {
   }
 };
 
+// src/models/voxtral_realtime/feature_extraction_voxtral_realtime.js
+var VoxtralRealtimeFeatureExtractor = class extends FeatureExtractor {
+  constructor(config) {
+    super(config);
+    this.config.mel_filters ??= mel_filter_bank(
+      Math.floor(1 + this.config.n_fft / 2),
+      // num_frequency_bins
+      this.config.feature_size,
+      // num_mel_filters
+      0,
+      // min_frequency
+      8e3,
+      // max_frequency
+      this.config.sampling_rate,
+      // sampling_rate
+      "slaney",
+      // norm
+      "slaney"
+      // mel_scale
+    );
+    this.window = window_function(this.config.n_fft, "hann");
+  }
+  /**
+   * Computes the log-Mel spectrogram of the provided audio waveform.
+   * @param {Float32Array|Float64Array} waveform The audio waveform to process.
+   * @param {Object} [options]
+   * @param {boolean} [options.center=true] Whether to center-pad the waveform for STFT.
+   * @returns {Promise<import('../../utils/tensor.js').Tensor>} The log-Mel spectrogram tensor of shape [num_mel_bins, num_frames].
+   */
+  async _extract_fbank_features(waveform, { center = true } = {}) {
+    const { n_fft, hop_length, mel_filters, global_log_mel_max } = this.config;
+    const max_num_frames = center ? Math.floor(waveform.length / hop_length) : Math.floor((waveform.length - n_fft) / hop_length);
+    return await spectrogram(
+      waveform,
+      this.window,
+      n_fft,
+      // frame_length
+      hop_length,
+      {
+        power: 2,
+        mel_filters,
+        log_mel: "log10_max_norm",
+        max_log_mel: global_log_mel_max,
+        center,
+        max_num_frames,
+        do_pad: false
+      }
+    );
+  }
+  /**
+   * Extract mel spectrogram features from audio.
+   * @param {Float32Array|Float64Array} audio The audio data.
+   * @param {Object} [options]
+   * @param {boolean} [options.center=true] Whether to center-pad the waveform.
+   * @returns {Promise<{ input_features: import('../../utils/tensor.js').Tensor }>}
+   */
+  async _call(audio, { center = true } = {}) {
+    validate_audio_inputs(audio, "VoxtralRealtimeFeatureExtractor");
+    const features = await this._extract_fbank_features(audio, { center });
+    return {
+      input_features: features.unsqueeze_(0)
+    };
+  }
+};
+
 // src/models/whisper/feature_extraction_whisper.js
 var WhisperFeatureExtractor = class extends FeatureExtractor {
   constructor(config) {
@@ -12948,7 +13442,7 @@ var WhisperFeatureExtractor = class extends FeatureExtractor {
    * @returns {Promise<Tensor>} An object containing the log-Mel spectrogram data as a Float32Array and its dimensions as an array of numbers.
    */
   async _extract_fbank_features(waveform) {
-    const features = await spectrogram(
+    return await spectrogram(
       waveform,
       this.window,
       // window
@@ -12959,7 +13453,7 @@ var WhisperFeatureExtractor = class extends FeatureExtractor {
       {
         power: 2,
         mel_filters: this.config.mel_filters,
-        log_mel: "log10",
+        log_mel: "log10_max_norm",
         // Custom
         max_num_frames: Math.min(
           Math.floor(waveform.length / this.config.hop_length),
@@ -12968,15 +13462,6 @@ var WhisperFeatureExtractor = class extends FeatureExtractor {
         )
       }
     );
-    const data = features.data;
-    const maxValue = max(
-      /** @type {Float32Array} */
-      data
-    )[0];
-    for (let i = 0; i < data.length; ++i) {
-      data[i] = (Math.max(data[i], maxValue - 8) + 4) / 4;
-    }
-    return features;
   }
   /**
    * Asynchronously extracts features from a given audio using the provided configuration.
@@ -13042,11 +13527,10 @@ var sharp_default = {};
 var createCanvasFunction;
 var ImageDataClass;
 var loadImageFunction;
-var IS_BROWSER_OR_WEBWORKER = apis.IS_BROWSER_ENV || apis.IS_WEBWORKER_ENV;
-if (IS_BROWSER_OR_WEBWORKER) {
+if (apis.IS_WEB_ENV) {
   createCanvasFunction = (width, height) => {
     if (!self.OffscreenCanvas) {
-      throw new Error("OffscreenCanvas not supported by this browser.");
+      throw new Error("OffscreenCanvas not supported by this environment.");
     }
     return new self.OffscreenCanvas(width, height);
   };
@@ -13136,7 +13620,7 @@ var RawImage = class _RawImage {
    * @returns {RawImage} The image object.
    */
   static fromCanvas(canvas) {
-    if (!IS_BROWSER_OR_WEBWORKER) {
+    if (!apis.IS_WEB_ENV) {
       throw new Error("fromCanvas() is only supported in browser environments.");
     }
     const ctx = (
@@ -13165,7 +13649,7 @@ var RawImage = class _RawImage {
    * @returns {Promise<RawImage>} The image object.
    */
   static async fromBlob(blob) {
-    if (IS_BROWSER_OR_WEBWORKER) {
+    if (apis.IS_WEB_ENV) {
       const img = await loadImageFunction(blob);
       const ctx = createCanvasFunction(img.width, img.height).getContext("2d");
       ctx.drawImage(img, 0, 0);
@@ -13346,7 +13830,7 @@ var RawImage = class _RawImage {
     } else if (nullish_height) {
       height = width / this.width * this.height;
     }
-    if (IS_BROWSER_OR_WEBWORKER) {
+    if (apis.IS_WEB_ENV) {
       const numChannels = this.channels;
       const canvas = this.toCanvas();
       const ctx = createCanvasFunction(width, height).getContext("2d");
@@ -13394,7 +13878,7 @@ var RawImage = class _RawImage {
     if (left === 0 && right === 0 && top === 0 && bottom === 0) {
       return this;
     }
-    if (IS_BROWSER_OR_WEBWORKER) {
+    if (apis.IS_WEB_ENV) {
       const numChannels = this.channels;
       const canvas = this.toCanvas();
       const newWidth = this.width + left + right;
@@ -13418,7 +13902,7 @@ var RawImage = class _RawImage {
     }
     const crop_width = x_max - x_min + 1;
     const crop_height = y_max - y_min + 1;
-    if (IS_BROWSER_OR_WEBWORKER) {
+    if (apis.IS_WEB_ENV) {
       const numChannels = this.channels;
       const canvas = this.toCanvas();
       const ctx = createCanvasFunction(crop_width, crop_height).getContext("2d");
@@ -13446,7 +13930,7 @@ var RawImage = class _RawImage {
     }
     const width_offset = (this.width - crop_width) / 2;
     const height_offset = (this.height - crop_height) / 2;
-    if (IS_BROWSER_OR_WEBWORKER) {
+    if (apis.IS_WEB_ENV) {
       const numChannels = this.channels;
       const canvas = this.toCanvas();
       const ctx = createCanvasFunction(crop_width, crop_height).getContext("2d");
@@ -13524,7 +14008,7 @@ var RawImage = class _RawImage {
     }
   }
   async toBlob(type = "image/png", quality = 1) {
-    if (!IS_BROWSER_OR_WEBWORKER) {
+    if (!apis.IS_WEB_ENV) {
       throw new Error("toBlob() is only supported in browser environments.");
     }
     const canvas = this.toCanvas();
@@ -13541,7 +14025,7 @@ var RawImage = class _RawImage {
     return tensor;
   }
   toCanvas() {
-    if (!IS_BROWSER_OR_WEBWORKER) {
+    if (!apis.IS_WEB_ENV) {
       throw new Error("toCanvas() is only supported in browser environments.");
     }
     const cloned = this.clone().rgba();
@@ -13625,7 +14109,7 @@ var RawImage = class _RawImage {
    * @returns {Promise<void>}
    */
   async save(path) {
-    if (IS_BROWSER_OR_WEBWORKER) {
+    if (apis.IS_WEB_ENV) {
       if (apis.IS_WEBWORKER_ENV) {
         throw new Error("Unable to save an image from a Web Worker.");
       }
@@ -13645,7 +14129,7 @@ var RawImage = class _RawImage {
    * @returns {import('sharp').Sharp} The Sharp instance.
    */
   toSharp() {
-    if (IS_BROWSER_OR_WEBWORKER) {
+    if (apis.IS_WEB_ENV) {
       throw new Error("toSharp() is only supported in server-side environments.");
     }
     return sharp_default(this.data, {
@@ -13858,6 +14342,27 @@ function compute_segments(mask_probs, pred_scores, pred_labels, mask_threshold,
   }
   return [segmentation, segments];
 }
+function smart_resize(height, width, factor = 28, min_pixels = 56 * 56, max_pixels = 14 * 14 * 4 * 1280) {
+  if (height < factor || width < factor) {
+    throw new Error(`height:${height} or width:${width} must be larger than factor:${factor}`);
+  } else if (Math.max(height, width) / Math.min(height, width) > 200) {
+    throw new Error(
+      `absolute aspect ratio must be smaller than 200, got ${Math.max(height, width) / Math.min(height, width)}`
+    );
+  }
+  let h_bar = Math.round(height / factor) * factor;
+  let w_bar = Math.round(width / factor) * factor;
+  if (h_bar * w_bar > max_pixels) {
+    const beta = Math.sqrt(height * width / max_pixels);
+    h_bar = Math.floor(height / beta / factor) * factor;
+    w_bar = Math.floor(width / beta / factor) * factor;
+  } else if (h_bar * w_bar < min_pixels) {
+    const beta = Math.sqrt(min_pixels / (height * width));
+    h_bar = Math.ceil(height * beta / factor) * factor;
+    w_bar = Math.ceil(width * beta / factor) * factor;
+  }
+  return [h_bar, w_bar];
+}
 function post_process_panoptic_segmentation(outputs, threshold = 0.5, mask_threshold = 0.5, overlap_mask_area_threshold = 0.8, label_ids_to_fuse = null, target_sizes = null) {
   if (label_ids_to_fuse === null) {
     logger.warn("`label_ids_to_fuse` unset. No instance will be fused.");
@@ -14146,7 +14651,7 @@ var ImageProcessor = class extends Callable2 {
     });
   }
   /**
-   * @typedef {object} PreprocessedImage
+   * @typedef {Object} PreprocessedImage
    * @property {HeightWidth} original_size The original size of the image.
    * @property {HeightWidth} reshaped_input_size The reshaped input size of the image.
    * @property {Tensor} pixel_values The pixel values of the preprocessed image.
@@ -14324,6 +14829,7 @@ __export(image_processors_exports, {
   ImageFeatureExtractor: () => ImageProcessor,
   ImageProcessor: () => ImageProcessor,
   JinaCLIPImageProcessor: () => JinaCLIPImageProcessor,
+  Lfm2VlImageProcessor: () => Lfm2VlImageProcessor,
   LlavaOnevisionImageProcessor: () => LlavaOnevisionImageProcessor,
   Mask2FormerImageProcessor: () => Mask2FormerImageProcessor,
   MaskFormerFeatureExtractor: () => MaskFormerFeatureExtractor,
@@ -14727,6 +15233,237 @@ var JinaCLIPImageProcessor = class extends ImageProcessor {
   }
 };
 
+// src/models/lfm2_vl/image_processing_lfm2_vl.js
+function round_by_factor(number, factor) {
+  return Math.round(number / factor) * factor;
+}
+function find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size) {
+  let best_ratio_diff = Infinity;
+  let best_ratio = [1, 1];
+  const area = width * height;
+  for (const ratio of target_ratios) {
+    const ratio_diff = Math.abs(aspect_ratio - ratio[0] / ratio[1]);
+    if (ratio_diff < best_ratio_diff) {
+      best_ratio_diff = ratio_diff;
+      best_ratio = ratio;
+    } else if (ratio_diff === best_ratio_diff && area > 0.5 * image_size * image_size * ratio[0] * ratio[1]) {
+      best_ratio = ratio;
+    }
+  }
+  return best_ratio;
+}
+function get_target_ratios(min_tiles, max_tiles) {
+  const ratios = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let n = min_tiles; n <= max_tiles; ++n) {
+    for (let w = 1; w <= n; ++w) {
+      for (let h = 1; h <= n; ++h) {
+        const product2 = w * h;
+        if (product2 >= min_tiles && product2 <= max_tiles) {
+          const key = w << 16 | h;
+          if (!seen.has(key)) {
+            seen.add(key);
+            ratios.push([w, h]);
+          }
+        }
+      }
+    }
+  }
+  return ratios.sort((a, b) => a[0] * a[1] - b[0] * b[1]);
+}
+function convert_image_to_patches(images, patch_size) {
+  const [B, C, H, W] = images.dims;
+  const ph = Math.floor(H / patch_size), pw = Math.floor(W / patch_size);
+  const patch_dim = patch_size * patch_size * C;
+  const data = (
+    /** @type {Float32Array} */
+    images.data
+  );
+  const result = new Float32Array(B * ph * pw * patch_dim);
+  const ch_stride = H * W;
+  for (let b = 0; b < B; ++b) {
+    const b_src = b * C * ch_stride;
+    const b_dst = b * ph * pw * patch_dim;
+    for (let py = 0; py < ph; ++py) {
+      for (let px = 0; px < pw; ++px) {
+        let off = b_dst + (py * pw + px) * patch_dim;
+        for (let dy = 0; dy < patch_size; ++dy) {
+          const row = (py * patch_size + dy) * W + px * patch_size;
+          for (let dx = 0; dx < patch_size; ++dx) {
+            const pixel = row + dx;
+            for (let c = 0; c < C; ++c) {
+              result[off++] = data[b_src + c * ch_stride + pixel];
+            }
+          }
+        }
+      }
+    }
+  }
+  return new Tensor2("float32", result, [B, ph * pw, patch_dim]);
+}
+function pad_along_first_dim(patches, target_length) {
+  const [, len2, dim] = patches.dims;
+  const mask_data = new BigInt64Array(target_length);
+  mask_data.fill(1n, 0, len2);
+  let padded = patches;
+  if (len2 < target_length) {
+    const padded_data = new Float32Array(target_length * dim);
+    padded_data.set(
+      /** @type {Float32Array} */
+      patches.data
+    );
+    padded = new Tensor2("float32", padded_data, [1, target_length, dim]);
+  }
+  return { padded, mask: new Tensor2("int64", mask_data, [target_length]) };
+}
+var Lfm2VlImageProcessor = class extends ImageProcessor {
+  constructor(config) {
+    super(config);
+    this.downsample_factor = config.downsample_factor ?? 2;
+    this.do_image_splitting = config.do_image_splitting ?? true;
+    this.min_tiles = config.min_tiles ?? 2;
+    this.max_tiles = config.max_tiles ?? 10;
+    this.use_thumbnail = config.use_thumbnail ?? true;
+    this.min_image_tokens = config.min_image_tokens ?? 64;
+    this.max_image_tokens = config.max_image_tokens ?? 256;
+    this.encoder_patch_size = config.encoder_patch_size ?? config.patch_size ?? 16;
+    this.tile_size = config.tile_size ?? 512;
+    this.max_pixels_tolerance = config.max_pixels_tolerance ?? 2;
+    this.return_row_col_info = config.return_row_col_info ?? false;
+    const max_thumbnail_patches = this.max_image_tokens * this.downsample_factor ** 2;
+    const tile_size_patches = this.do_image_splitting ? (this.tile_size / this.encoder_patch_size) ** 2 : 0;
+    this.max_num_patches = Math.max(max_thumbnail_patches, tile_size_patches);
+  }
+  /**
+   * Check if the image is too large to be processed as a single tile.
+   * @param {number} height
+   * @param {number} width
+   * @returns {boolean}
+   */
+  _is_image_too_large(height, width) {
+    const total_factor = this.encoder_patch_size * this.downsample_factor;
+    const h_bar = Math.max(this.encoder_patch_size, round_by_factor(height, total_factor));
+    const w_bar = Math.max(this.encoder_patch_size, round_by_factor(width, total_factor));
+    return h_bar * w_bar > this.max_image_tokens * (this.encoder_patch_size * this.downsample_factor) ** 2 * this.max_pixels_tolerance;
+  }
+  /**
+   * Get the grid layout for tiling a large image.
+   * @param {number} height
+   * @param {number} width
+   * @returns {{ grid_width: number, grid_height: number, target_width: number, target_height: number }}
+   */
+  _get_grid_layout(height, width) {
+    const target_ratios = get_target_ratios(this.min_tiles, this.max_tiles);
+    const [grid_width, grid_height] = find_closest_aspect_ratio(
+      width / height,
+      target_ratios,
+      width,
+      height,
+      this.tile_size
+    );
+    return {
+      grid_width,
+      grid_height,
+      target_width: this.tile_size * grid_width,
+      target_height: this.tile_size * grid_height
+    };
+  }
+  /** @param {RawImage|RawImage[]|RawImage[][]} images */
+  // @ts-expect-error
+  async _call(images, { return_row_col_info = null } = {}) {
+    let batched_images;
+    if (!Array.isArray(images)) {
+      batched_images = [[images]];
+    } else if (!Array.isArray(images[0])) {
+      batched_images = [
+        /** @type {RawImage[]} */
+        images
+      ];
+    } else {
+      batched_images = /** @type {RawImage[][]} */
+      images;
+    }
+    const all_pixel_values = [];
+    const all_pixel_masks = [];
+    const all_spatial_shapes = [];
+    const all_rows = [];
+    const all_cols = [];
+    const all_image_sizes = [];
+    for (const image_batch of batched_images) {
+      const preprocessed = await Promise.all(image_batch.map((x) => this.preprocess(x, { do_pad: false })));
+      for (const { pixel_values } of preprocessed) {
+        const [, height, width] = pixel_values.dims;
+        const img = pixel_values.unsqueeze_(0);
+        const total_factor = this.encoder_patch_size * this.downsample_factor;
+        const f2 = total_factor ** 2;
+        const [new_height, new_width] = smart_resize(
+          Math.max(total_factor, height),
+          Math.max(total_factor, width),
+          total_factor,
+          this.min_image_tokens * f2,
+          this.max_image_tokens * f2
+        ).map((x) => Math.max(total_factor, x));
+        let tiles;
+        let num_rows = 1, num_cols = 1;
+        const is_large = this._is_image_too_large(height, width);
+        const do_splitting = this.do_image_splitting && !(this.min_tiles === 1 && this.max_tiles === 1);
+        if (is_large && do_splitting) {
+          const { grid_width, grid_height, target_width, target_height } = this._get_grid_layout(
+            height,
+            width
+          );
+          num_rows = grid_height;
+          num_cols = grid_width;
+          const resized = await interpolate_4d(img, {
+            size: [target_height, target_width]
+          });
+          tiles = [];
+          for (let r = 0; r < grid_height; ++r) {
+            for (let c = 0; c < grid_width; ++c) {
+              const y = r * this.tile_size;
+              const x = c * this.tile_size;
+              tiles.push(resized.slice(null, null, [y, y + this.tile_size], [x, x + this.tile_size]));
+            }
+          }
+          if (this.use_thumbnail && grid_width * grid_height !== 1) {
+            tiles.push(await interpolate_4d(img, { size: [new_height, new_width] }));
+          }
+        } else {
+          tiles = [await interpolate_4d(img, { size: [new_height, new_width] })];
+        }
+        for (const tile of tiles) {
+          const [, , th, tw] = tile.dims;
+          const patches = convert_image_to_patches(tile, this.encoder_patch_size);
+          const { padded, mask } = pad_along_first_dim(patches, this.max_num_patches);
+          all_pixel_values.push(padded);
+          all_pixel_masks.push(mask);
+          all_spatial_shapes.push([
+            Math.floor(th / this.encoder_patch_size),
+            Math.floor(tw / this.encoder_patch_size)
+          ]);
+        }
+        all_rows.push(num_rows);
+        all_cols.push(num_cols);
+        all_image_sizes.push([new_height, new_width]);
+      }
+    }
+    const result = {
+      pixel_values: cat(all_pixel_values, 0),
+      pixel_attention_mask: stack(all_pixel_masks, 0),
+      spatial_shapes: new Tensor2("int64", BigInt64Array.from(all_spatial_shapes.flat(), BigInt), [
+        all_spatial_shapes.length,
+        2
+      ])
+    };
+    if (return_row_col_info ?? this.return_row_col_info) {
+      result.image_rows = all_rows;
+      result.image_cols = all_cols;
+      result.image_sizes = all_image_sizes;
+    }
+    return result;
+  }
+};
+
 // src/models/llava_onevision/image_processing_llava_onevision.js
 var LlavaOnevisionImageProcessor = class extends ImageProcessor {
 };
@@ -14950,27 +15687,6 @@ var PvtImageProcessor = class extends ImageProcessor {
 };
 
 // src/models/qwen2_vl/image_processing_qwen2_vl.js
-function smart_resize(height, width, factor = 28, min_pixels = 56 * 56, max_pixels = 14 * 14 * 4 * 1280) {
-  if (height < factor || width < factor) {
-    throw new Error(`height:${height} or width:${width} must be larger than factor:${factor}`);
-  } else if (Math.max(height, width) / Math.min(height, width) > 200) {
-    throw new Error(
-      `absolute aspect ratio must be smaller than 200, got ${Math.max(height, width) / Math.min(height, width)}`
-    );
-  }
-  let h_bar = Math.round(height / factor) * factor;
-  let w_bar = Math.round(width / factor) * factor;
-  if (h_bar * w_bar > max_pixels) {
-    const beta = Math.sqrt(height * width / max_pixels);
-    h_bar = Math.floor(height / beta / factor) * factor;
-    w_bar = Math.floor(width / beta / factor) * factor;
-  } else if (h_bar * w_bar < min_pixels) {
-    const beta = Math.sqrt(min_pixels / (height * width));
-    h_bar = Math.ceil(height * beta / factor) * factor;
-    w_bar = Math.ceil(width * beta / factor) * factor;
-  }
-  return [h_bar, w_bar];
-}
 var Qwen2VLImageProcessor = class extends ImageProcessor {
   constructor(config) {
     super(config);
@@ -15572,6 +16288,57 @@ ${boi_token}${image_tokens_expanded}${eoi_token}
   }
 };
 
+// src/models/granite_speech/processing_granite_speech.js
+var GraniteSpeechProcessor = class extends Processor {
+  static tokenizer_class = AutoTokenizer;
+  static feature_extractor_class = AutoFeatureExtractor;
+  static uses_processor_config = true;
+  /**
+   * Compute the number of audio tokens for a given raw audio length.
+   * @param {number} audioLength Raw audio sample count.
+   * @returns {number} Number of projector output tokens.
+   */
+  _get_num_audio_features(audioLength) {
+    const { hop_length } = this.feature_extractor.config.melspec_kwargs;
+    const { projector_window_size, projector_downsample_rate } = this.feature_extractor.config;
+    const effective_window_size = Math.floor(projector_window_size / projector_downsample_rate);
+    const mel_length = Math.floor(audioLength / hop_length) + 1;
+    const encoder_length = Math.floor(mel_length / 2);
+    const nblocks = Math.ceil(encoder_length / projector_window_size);
+    return nblocks * effective_window_size;
+  }
+  /**
+   * @param {string} text The text input to process.
+   * @param {Float32Array} audio The audio input to process.
+   */
+  async _call(text, audio = null, kwargs = {}) {
+    if (Array.isArray(text)) {
+      throw new Error("Batched inputs are not supported yet.");
+    }
+    let audio_inputs = {};
+    if (audio) {
+      const { input_features } = await this.feature_extractor(audio);
+      audio_inputs["input_features"] = input_features;
+      const audio_embed_size = this._get_num_audio_features(audio.length);
+      const mask_data = new Uint8Array(audio_embed_size).fill(1);
+      audio_inputs["input_features_mask"] = new Tensor2("bool", mask_data, [1, audio_embed_size]);
+      const audio_token = this.config.audio_token ?? "<|audio|>";
+      if (!text.includes(audio_token)) {
+        throw new Error(`The input text does not contain the audio token ${audio_token}.`);
+      }
+      text = text.replaceAll(audio_token, audio_token.repeat(audio_embed_size));
+    }
+    const text_inputs = this.tokenizer(text, {
+      add_special_tokens: false,
+      ...kwargs
+    });
+    return {
+      ...text_inputs,
+      ...audio_inputs
+    };
+  }
+};
+
 // src/models/grounding_dino/processing_grounding_dino.js
 function get_phrases_from_posmap(posmaps, input_ids) {
   const left_idx = 0;
@@ -15848,6 +16615,66 @@ var JinaCLIPProcessor = class extends Processor {
   }
 };
 
+// src/models/lfm2_vl/processing_lfm2_vl.js
+var Lfm2VlProcessor = class extends Processor {
+  static tokenizer_class = AutoTokenizer;
+  static image_processor_class = AutoImageProcessor;
+  /**
+   * @param {RawImage|RawImage[]} images
+   * @param {string|string[]|null} [text]
+   * @param {Record<string, any>} [kwargs]
+   */
+  async _call(images, text = null, kwargs = {}) {
+    const { image_rows, image_cols, image_sizes, ...image_inputs } = await this.image_processor(images, {
+      ...kwargs,
+      return_row_col_info: true
+    });
+    if (text) {
+      const image_token = this.config.image_token ?? "<image>";
+      const {
+        tile_size = 512,
+        downsample_factor = 2,
+        encoder_patch_size = 16,
+        use_thumbnail = true
+      } = (
+        /** @type {Record<string, any>} */
+        this.image_processor.config
+      );
+      const ds = (s) => Math.ceil(Math.floor(s / encoder_patch_size) / downsample_factor);
+      const tokens_per_tile = ds(tile_size) ** 2;
+      const image_start = this.config.image_start_token ?? "<|image_start|>";
+      const image_end = this.config.image_end_token ?? "<|image_end|>";
+      const thumbnail_token = this.config.image_thumbnail ?? "<|img_thumbnail|>";
+      if (!Array.isArray(text)) text = [text];
+      let image_idx = 0;
+      text = text.map((sample) => {
+        const parts = sample.split(image_token);
+        return parts[0] + parts.slice(1).map((part) => {
+          const idx = image_idx++;
+          const [h, w] = image_sizes[idx];
+          const rows = image_rows[idx], cols = image_cols[idx];
+          const tokens_for_image = ds(h) * ds(w);
+          let expanded = image_start;
+          if (rows > 1 || cols > 1) {
+            const tile_str = image_token.repeat(tokens_per_tile);
+            for (let r = 0; r < rows; ++r)
+              for (let c = 0; c < cols; ++c)
+                expanded += `<|img_row_${r + 1}_col_${c + 1}|>` + tile_str;
+            if (use_thumbnail) expanded += thumbnail_token + image_token.repeat(tokens_for_image);
+          } else {
+            expanded += image_token.repeat(tokens_for_image);
+          }
+          return expanded + image_end + part;
+        }).join("");
+      });
+    }
+    return {
+      ...image_inputs,
+      ...text ? this.tokenizer(text, kwargs) : {}
+    };
+  }
+};
+
 // src/models/llava/processing_llava.js
 var LlavaProcessor = class extends Processor {
   static tokenizer_class = AutoTokenizer;
@@ -16367,16 +17194,104 @@ var VoxtralProcessor = class extends Processor {
         }
         new_text += text_parts[i + 1];
       }
-      text = new_text;
+      text = new_text;
+    }
+    const text_inputs = this.tokenizer(text, {
+      add_special_tokens: false,
+      ...kwargs
+    });
+    return {
+      ...text_inputs,
+      ...audio_inputs
+    };
+  }
+};
+
+// src/models/voxtral_realtime/processing_voxtral_realtime.js
+var NUM_LEFT_PAD_TOKENS = 32;
+var NUM_DELAY_TOKENS = 6;
+var AUDIO_LENGTH_PER_TOK = 8;
+var OFFLINE_STREAMING_BUFFER_TOKENS = 10;
+var STREAMING_PAD_TOKEN_ID = 32;
+var VoxtralRealtimeProcessor = class extends Processor {
+  static tokenizer_class = AutoTokenizer;
+  static feature_extractor_class = AutoFeatureExtractor;
+  static uses_processor_config = false;
+  /** Number of mel frames in the first audio chunk. */
+  get num_mel_frames_first_audio_chunk() {
+    return (NUM_DELAY_TOKENS + 1) * AUDIO_LENGTH_PER_TOK;
+  }
+  /** Number of raw audio samples in the first audio chunk. */
+  get num_samples_first_audio_chunk() {
+    const { hop_length, n_fft } = this.feature_extractor.config;
+    return (this.num_mel_frames_first_audio_chunk - 1) * hop_length + Math.floor(n_fft / 2);
+  }
+  /** Number of raw audio samples per subsequent audio chunk. */
+  get num_samples_per_audio_chunk() {
+    const { hop_length, n_fft } = this.feature_extractor.config;
+    return AUDIO_LENGTH_PER_TOK * hop_length + n_fft;
+  }
+  /** Number of right-pad tokens for non-streaming mode. */
+  get num_right_pad_tokens() {
+    return NUM_DELAY_TOKENS + 1 + OFFLINE_STREAMING_BUFFER_TOKENS;
+  }
+  /** Number of mel frames per text token. */
+  get audio_length_per_tok() {
+    return AUDIO_LENGTH_PER_TOK;
+  }
+  /** Number of raw audio samples per token. */
+  get raw_audio_length_per_tok() {
+    return AUDIO_LENGTH_PER_TOK * this.feature_extractor.config.hop_length;
+  }
+  /**
+   * Process audio input for VoxtralRealtime.
+   *
+   * In streaming mode with `is_first_audio_chunk=true`, the audio is left-padded
+   * with silence and mel features are extracted with `center=true`.
+   * Returns `{ input_ids, input_features }`.
+   *
+   * In streaming mode with `is_first_audio_chunk=false`, the audio chunk is
+   * processed with `center=false` and only `{ input_features }` is returned.
+   *
+   * In non-streaming mode, the audio is right-padded to ensure the model
+   * transcribes the full audio, then processed with `center=true`.
+   * Returns `{ input_features }`.
+   *
+   * @param {Float32Array|Float64Array} audio The audio waveform.
+   * @param {Object} [options]
+   * @param {boolean} [options.is_streaming=false] Whether processing in streaming mode.
+   * @param {boolean} [options.is_first_audio_chunk=true] Whether this is the first audio chunk.
+   * @returns {Promise<Object>}
+   */
+  async _call(audio, { is_streaming = false, is_first_audio_chunk = true } = {}) {
+    validate_audio_inputs(audio, "VoxtralRealtimeProcessor");
+    if (!is_streaming && !is_first_audio_chunk) {
+      throw new Error("In non-streaming mode (`is_streaming=false`), `is_first_audio_chunk` must be `true`.");
+    }
+    if (is_first_audio_chunk) {
+      if (is_streaming) {
+        const num_left_pad_samples = NUM_LEFT_PAD_TOKENS * this.raw_audio_length_per_tok;
+        const padded_audio = new Float32Array(num_left_pad_samples + audio.length);
+        padded_audio.set(audio, num_left_pad_samples);
+        const audio_encoding = await this.feature_extractor(padded_audio, { center: true });
+        const num_pad_tokens = NUM_LEFT_PAD_TOKENS + NUM_DELAY_TOKENS;
+        const num_input_tokens = 1 + num_pad_tokens;
+        const input_ids_data = new BigInt64Array(num_input_tokens).fill(BigInt(STREAMING_PAD_TOKEN_ID));
+        input_ids_data[0] = 1n;
+        const input_ids = new Tensor2("int64", input_ids_data, [1, num_input_tokens]);
+        return {
+          input_ids,
+          ...audio_encoding
+        };
+      } else {
+        const right_pad_samples = this.num_right_pad_tokens * this.raw_audio_length_per_tok;
+        const padded_audio = new Float32Array(audio.length + right_pad_samples);
+        padded_audio.set(audio);
+        return await this.feature_extractor(padded_audio, { center: true });
+      }
+    } else {
+      return await this.feature_extractor(audio, { center: false });
     }
-    const text_inputs = this.tokenizer(text, {
-      add_special_tokens: false,
-      ...kwargs
-    });
-    return {
-      ...text_inputs,
-      ...audio_inputs
-    };
   }
 };
 
@@ -16479,14 +17394,18 @@ function getNormalizedConfig(config) {
     case "florence2":
     case "llava_onevision":
     case "idefics3":
+    case "granite_speech":
     case "ultravox":
     case "voxtral":
+    case "voxtral_realtime":
     case "smolvlm":
     case "gemma3n":
+    case "lfm2_vl":
     case "chatterbox":
     case "mistral3":
     case "qwen2_5_vl":
     case "qwen3_vl":
+    case "qwen3_vl_moe":
       init_normalized_config = getNormalizedConfig(config.text_config);
       break;
     case "moondream1":
@@ -16536,11 +17455,17 @@ function getNormalizedConfig(config) {
     case "cohere":
     case "cohere2":
     case "mistral":
+    case "voxtral_realtime_text":
+    case "voxtral_realtime_encoder":
     case "starcoder2":
     case "qwen2":
+    case "qwen2_moe":
     case "qwen2_vl":
+    case "qwen2_vl_text":
     case "qwen2_5_vl_text":
+    case "qwen3_moe":
     case "qwen3_vl_text":
+    case "qwen3_vl_moe_text":
     case "phi":
     case "phi3":
     case "phi3_v":
@@ -16681,6 +17606,9 @@ function getNormalizedConfig(config) {
   return normalized_config;
 }
 function getCacheShapes(config, options) {
+  if (!(config instanceof PretrainedConfig)) {
+    config = new PretrainedConfig(config);
+  }
   if (["lfm2", "lfm2_moe"].includes(config.model_type)) {
     const pkv_prefix = options?.prefix ?? "past_key_values";
     const conv_prefix = pkv_prefix === "present" ? "present" : "past";
@@ -16739,7 +17667,7 @@ function getCacheShapes(config, options) {
       }
     }
     return cache_values;
-  } else if (["qwen3_5", "qwen3_5_moe"].includes(config.model_type)) {
+  } else if (["qwen3_next", "qwen3_5_text", "qwen3_5_moe_text", "olmo_hybrid"].includes(config.model_type)) {
     const pkv_prefix = options?.prefix ?? "past_key_values";
     const conv_prefix = pkv_prefix === "present" ? "present" : "past";
     const cache_values = {};
@@ -16756,11 +17684,10 @@ function getCacheShapes(config, options) {
       linear_conv_kernel_dim
     } = (
       /** @type {any} */
-      config.text_config
+      config
     );
     const key_dim = linear_key_head_dim * linear_num_key_heads;
     const value_dim = linear_value_head_dim * linear_num_value_heads;
-    const conv_dim = key_dim * 2 + value_dim;
     const final_head_dim = head_dim ?? hidden_size / num_attention_heads;
     const batch_size = options?.batch_size ?? 1;
     for (let i = 0; i < layer_types.length; ++i) {
@@ -16769,7 +17696,14 @@ function getCacheShapes(config, options) {
           cache_values[`${pkv_prefix}.${i}.${kv}`] = [batch_size, num_key_value_heads, 0, final_head_dim];
         }
       } else if (layer_types[i] === "linear_attention") {
-        cache_values[`${conv_prefix}_conv.${i}`] = [batch_size, conv_dim, linear_conv_kernel_dim];
+        if (config.model_type === "olmo_hybrid") {
+          cache_values[`${conv_prefix}_conv.${i}.key`] = [batch_size, key_dim, linear_conv_kernel_dim];
+          cache_values[`${conv_prefix}_conv.${i}.value`] = [batch_size, value_dim, linear_conv_kernel_dim];
+          cache_values[`${conv_prefix}_conv.${i}.query`] = [batch_size, key_dim, linear_conv_kernel_dim];
+        } else {
+          const conv_dim = key_dim * 2 + value_dim;
+          cache_values[`${conv_prefix}_conv.${i}`] = [batch_size, conv_dim, linear_conv_kernel_dim];
+        }
         cache_values[`${conv_prefix}_recurrent.${i}`] = [
           batch_size,
           linear_num_value_heads,
@@ -16781,6 +17715,16 @@ function getCacheShapes(config, options) {
       }
     }
     return cache_values;
+  } else if (["lfm2_vl", "qwen3_5", "qwen3_5_moe", "voxtral_realtime"].includes(config.model_type)) {
+    let subConfig;
+    if (config.model_type === "voxtral_realtime" && options?.session_name === "audio_encoder") {
+      subConfig = /** @type {any} */
+      config.audio_config;
+    } else {
+      subConfig = /** @type {any} */
+      config.text_config;
+    }
+    return getCacheShapes(subConfig, options);
   }
   return getKeyValueShapes(config, options);
 }
@@ -16946,7 +17890,7 @@ async function getModelDataFiles(pretrained_model_name_or_path, fileName, suffix
 }
 
 // src/models/session.js
-async function getSession(pretrained_model_name_or_path, fileName, options, is_decoder = false) {
+async function getSession(pretrained_model_name_or_path, fileName, options, cache_config = false, session_name = void 0) {
   let custom_config = options.config?.["transformers.js_config"] ?? {};
   const selectedDevice = (
     /** @type {import("../utils/devices.js").DeviceType} */
@@ -17004,9 +17948,10 @@ async function getSession(pretrained_model_name_or_path, fileName, options, is_d
   if (externalData.length > 0 && !apis.IS_NODE_ENV) {
     session_options.externalData = externalData;
   }
-  if (is_decoder && selectedDevice === "webgpu" && kv_cache_dtype_config !== false) {
+  if (cache_config && selectedDevice === "webgpu" && kv_cache_dtype_config !== false) {
     const shapes = getCacheShapes(options.config, {
-      prefix: "present"
+      prefix: "present",
+      session_name
     });
     if (Object.keys(shapes).length > 0 && !isONNXProxy()) {
       const preferredOutputLocation = {};
@@ -17024,15 +17969,17 @@ async function getSession(pretrained_model_name_or_path, fileName, options, is_d
   };
   return { buffer_or_path, session_options, session_config };
 }
-async function constructSessions(pretrained_model_name_or_path, names, options, decoder_name = void 0) {
+async function constructSessions(pretrained_model_name_or_path, names, options, cache_sessions = void 0) {
   return Object.fromEntries(
     await Promise.all(
       Object.keys(names).map(async (name) => {
+        const cache_config = cache_sessions?.[name] ?? false;
         const { buffer_or_path, session_options, session_config } = await getSession(
           pretrained_model_name_or_path,
           names[name],
           options,
-          name === decoder_name
+          cache_config,
+          name
         );
         const session = await createInferenceSession(buffer_or_path, session_options, session_config);
         return [name, session];
@@ -18332,6 +19279,66 @@ var BeamSearchSampler = class extends LogitsSampler {
   }
 };
 
+// src/cache_utils.js
+var _DynamicCache = class {
+  /**
+   * Create a DynamicCache, optionally pre-populated with entries.
+   * @param {Record<string, Tensor>} [entries] Initial name→Tensor mappings.
+   */
+  constructor(entries) {
+    if (!entries) return;
+    for (const key in entries) {
+      if (key in this) {
+        throw new TypeError(`Key "${key}" conflicts with an existing property on DynamicCache`);
+      }
+      const value = entries[key];
+      if (!(value instanceof Tensor2)) {
+        throw new TypeError(`Expected a Tensor for key "${key}", got ${typeof value}`);
+      }
+      this[key] = value;
+    }
+  }
+  /**
+   * Get the cached sequence length. This requires at least one attention cache entry to be present.
+   * @returns {number} The past sequence length.
+   */
+  get_seq_length() {
+    const self2 = (
+      /** @type {any} */
+      this
+    );
+    for (const name in self2) {
+      if (name.startsWith("past_key_values.")) {
+        return self2[name].dims.at(-2);
+      }
+    }
+    throw new Error("Unable to determine sequence length from the cache.");
+  }
+  /**
+   * Dispose all contained tensors whose data resides on the GPU.
+   * Returns a promise that resolves when all disposals are complete.
+   * @returns {Promise<void>} Promise that resolves when all GPU tensors are disposed.
+   */
+  async dispose() {
+    const promises = [];
+    for (
+      const t of
+      /** @type {Tensor[]} */
+      Object.values(this)
+    ) {
+      if (t.location === "gpu-buffer") {
+        promises.push(t.dispose());
+      }
+    }
+    await Promise.all(promises);
+  }
+};
+var DynamicCache = (
+  /** @type {new (entries?: Record<string, Tensor>) => DynamicCache} */
+  /** @type {unknown} */
+  _DynamicCache
+);
+
 // src/models/modeling_utils.js
 var MODEL_MAPPING_NAMES = null;
 function registerTaskMappings(mappings) {
@@ -18377,71 +19384,181 @@ var MODEL_TYPES = {
   AutoEncoder: 12,
   ImageAudioTextToText: 13,
   Supertonic: 14,
-  Chatterbox: 15
+  Chatterbox: 15,
+  MultimodalLanguageModelOnly: 16,
+  VoxtralRealtime: 17
 };
 var MODEL_TYPE_CONFIG = {
   [MODEL_TYPES.DecoderOnly]: {
     can_generate: true,
     forward: decoder_forward,
-    prepare_inputs: decoder_prepare_inputs_for_generation
+    prepare_inputs: decoder_prepare_inputs_for_generation,
+    sessions: (config, options) => ({ model: options.model_file_name ?? "model" }),
+    cache_sessions: { model: true },
+    optional_configs: { generation_config: "generation_config.json" }
   },
   [MODEL_TYPES.DecoderOnlyWithoutHead]: {
     can_generate: false,
     forward: decoder_forward,
-    prepare_inputs: decoder_prepare_inputs_for_generation
+    prepare_inputs: decoder_prepare_inputs_for_generation,
+    sessions: (config, options) => ({ model: options.model_file_name ?? "model" })
   },
   [MODEL_TYPES.Seq2Seq]: {
     can_generate: true,
     forward: seq2seq_forward,
-    prepare_inputs: encoder_decoder_prepare_inputs_for_generation
+    prepare_inputs: encoder_decoder_prepare_inputs_for_generation,
+    sessions: () => ({ model: "encoder_model", decoder_model_merged: "decoder_model_merged" }),
+    cache_sessions: { decoder_model_merged: true },
+    optional_configs: { generation_config: "generation_config.json" }
   },
   [MODEL_TYPES.Vision2Seq]: {
     can_generate: true,
     forward: seq2seq_forward,
-    prepare_inputs: encoder_decoder_prepare_inputs_for_generation
+    prepare_inputs: encoder_decoder_prepare_inputs_for_generation,
+    sessions: () => ({ model: "encoder_model", decoder_model_merged: "decoder_model_merged" }),
+    cache_sessions: { decoder_model_merged: true },
+    optional_configs: { generation_config: "generation_config.json" }
   },
   [MODEL_TYPES.Musicgen]: {
     can_generate: true,
-    forward: seq2seq_forward
+    forward: seq2seq_forward,
+    sessions: () => ({
+      model: "text_encoder",
+      decoder_model_merged: "decoder_model_merged",
+      encodec_decode: "encodec_decode"
+    }),
+    cache_sessions: { decoder_model_merged: true },
+    optional_configs: { generation_config: "generation_config.json" }
   },
   [MODEL_TYPES.EncoderDecoder]: {
     can_generate: false,
-    forward: seq2seq_forward
+    forward: seq2seq_forward,
+    sessions: () => ({ model: "encoder_model", decoder_model_merged: "decoder_model_merged" }),
+    cache_sessions: { decoder_model_merged: true }
+  },
+  [MODEL_TYPES.MaskGeneration]: {
+    sessions: () => ({ model: "vision_encoder", prompt_encoder_mask_decoder: "prompt_encoder_mask_decoder" })
   },
   [MODEL_TYPES.ImageTextToText]: {
     can_generate: true,
     forward: image_text_to_text_forward,
-    prepare_inputs: multimodal_text_to_text_prepare_inputs_for_generation
+    prepare_inputs: multimodal_text_to_text_prepare_inputs_for_generation,
+    sessions: (config) => {
+      const s = {
+        embed_tokens: "embed_tokens",
+        vision_encoder: "vision_encoder",
+        decoder_model_merged: "decoder_model_merged"
+      };
+      if (config.is_encoder_decoder) s["model"] = "encoder_model";
+      return s;
+    },
+    cache_sessions: { decoder_model_merged: true },
+    optional_configs: { generation_config: "generation_config.json" }
   },
   [MODEL_TYPES.AudioTextToText]: {
     can_generate: true,
     forward: audio_text_to_text_forward,
-    prepare_inputs: multimodal_text_to_text_prepare_inputs_for_generation
+    prepare_inputs: multimodal_text_to_text_prepare_inputs_for_generation,
+    sessions: () => ({
+      embed_tokens: "embed_tokens",
+      audio_encoder: "audio_encoder",
+      decoder_model_merged: "decoder_model_merged"
+    }),
+    cache_sessions: { decoder_model_merged: true },
+    optional_configs: { generation_config: "generation_config.json" }
   },
-  [MODEL_TYPES.Phi3V]: {
+  [MODEL_TYPES.ImageAudioTextToText]: {
     can_generate: true,
-    prepare_inputs: multimodal_text_to_text_prepare_inputs_for_generation
+    prepare_inputs: multimodal_text_to_text_prepare_inputs_for_generation,
+    sessions: () => ({
+      embed_tokens: "embed_tokens",
+      audio_encoder: "audio_encoder",
+      vision_encoder: "vision_encoder",
+      decoder_model_merged: "decoder_model_merged"
+    }),
+    optional_configs: { generation_config: "generation_config.json" }
   },
-  [MODEL_TYPES.ImageAudioTextToText]: {
+  [MODEL_TYPES.Phi3V]: {
     can_generate: true,
-    prepare_inputs: multimodal_text_to_text_prepare_inputs_for_generation
+    prepare_inputs: multimodal_text_to_text_prepare_inputs_for_generation,
+    sessions: () => ({
+      prepare_inputs_embeds: "prepare_inputs_embeds",
+      model: "model",
+      vision_encoder: "vision_encoder"
+    }),
+    cache_sessions: { model: true },
+    optional_configs: { generation_config: "generation_config.json" }
   },
   [MODEL_TYPES.MultiModality]: {
-    can_generate: true
+    can_generate: true,
+    sessions: () => ({
+      prepare_inputs_embeds: "prepare_inputs_embeds",
+      model: "language_model",
+      lm_head: "lm_head",
+      gen_head: "gen_head",
+      gen_img_embeds: "gen_img_embeds",
+      image_decode: "image_decode"
+    }),
+    cache_sessions: { model: true },
+    optional_configs: { generation_config: "generation_config.json" }
   },
   [MODEL_TYPES.AutoEncoder]: {
     can_generate: false,
-    forward: auto_encoder_forward
+    forward: auto_encoder_forward,
+    sessions: () => ({ encoder_model: "encoder_model", decoder_model: "decoder_model" })
+  },
+  [MODEL_TYPES.Supertonic]: {
+    sessions: () => ({
+      text_encoder: "text_encoder",
+      latent_denoiser: "latent_denoiser",
+      voice_decoder: "voice_decoder"
+    })
   },
   [MODEL_TYPES.Chatterbox]: {
     can_generate: true,
-    forward: encoder_forward
+    forward: encoder_forward,
+    sessions: () => ({
+      embed_tokens: "embed_tokens",
+      speech_encoder: "speech_encoder",
+      model: "language_model",
+      conditional_decoder: "conditional_decoder"
+    }),
+    cache_sessions: { model: true },
+    optional_configs: { generation_config: "generation_config.json" }
+  },
+  [MODEL_TYPES.MultimodalLanguageModelOnly]: {
+    can_generate: true,
+    forward: image_text_to_text_forward,
+    prepare_inputs: multimodal_text_to_text_prepare_inputs_for_generation,
+    sessions: () => ({ embed_tokens: "embed_tokens", decoder_model_merged: "decoder_model_merged" }),
+    cache_sessions: { decoder_model_merged: true },
+    optional_configs: { generation_config: "generation_config.json" }
+  },
+  [MODEL_TYPES.VoxtralRealtime]: {
+    can_generate: true,
+    prepare_inputs: decoder_prepare_inputs_for_generation,
+    sessions: () => ({
+      embed_tokens: "embed_tokens",
+      audio_encoder: "audio_encoder",
+      decoder_model_merged: "decoder_model_merged"
+    }),
+    cache_sessions: { decoder_model_merged: true, audio_encoder: true },
+    optional_configs: { generation_config: "generation_config.json" }
   },
   default: {
     can_generate: false,
-    forward: encoder_forward
+    forward: encoder_forward,
+    sessions: (config, options) => ({ model: options.model_file_name ?? "model" })
   }
 };
+function getSessionsConfig(modelType, config, options = {}) {
+  const typeConfig = MODEL_TYPE_CONFIG[modelType] ?? MODEL_TYPE_CONFIG.default;
+  return {
+    sessions: typeConfig.sessions(config, options),
+    cache_sessions: typeConfig.cache_sessions,
+    optional_configs: typeConfig.optional_configs
+  };
+}
 var MODEL_TYPE_MAPPING = /* @__PURE__ */ new Map();
 var MODEL_NAME_TO_CLASS_MAPPING = /* @__PURE__ */ new Map();
 var MODEL_CLASS_TO_NAME_MAPPING = /* @__PURE__ */ new Map();
@@ -18527,245 +19644,23 @@ var PreTrainedModel = class extends Callable2 {
     const modelName = MODEL_CLASS_TO_NAME_MAPPING.get(this);
     const modelType = MODEL_TYPE_MAPPING.get(modelName);
     config = options.config = await AutoConfig.from_pretrained(pretrained_model_name_or_path, options);
-    let info;
-    if (modelType === MODEL_TYPES.DecoderOnly) {
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            model: options.model_file_name ?? "model"
-          },
-          options,
-          "model"
-        ),
-        get_optional_configs(
-          pretrained_model_name_or_path,
-          {
-            generation_config: "generation_config.json"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.Seq2Seq || modelType === MODEL_TYPES.Vision2Seq) {
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            model: "encoder_model",
-            decoder_model_merged: "decoder_model_merged"
-          },
-          options,
-          "decoder_model_merged"
-        ),
-        get_optional_configs(
-          pretrained_model_name_or_path,
-          {
-            generation_config: "generation_config.json"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.MaskGeneration) {
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            model: "vision_encoder",
-            prompt_encoder_mask_decoder: "prompt_encoder_mask_decoder"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.EncoderDecoder) {
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            model: "encoder_model",
-            decoder_model_merged: "decoder_model_merged"
-          },
-          options,
-          "decoder_model_merged"
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.ImageTextToText) {
-      const sessions = {
-        embed_tokens: "embed_tokens",
-        vision_encoder: "vision_encoder",
-        decoder_model_merged: "decoder_model_merged"
-      };
-      if (config.is_encoder_decoder) {
-        sessions["model"] = "encoder_model";
-      }
-      info = await Promise.all([
-        constructSessions(pretrained_model_name_or_path, sessions, options, "decoder_model_merged"),
-        get_optional_configs(
-          pretrained_model_name_or_path,
-          {
-            generation_config: "generation_config.json"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.AudioTextToText) {
-      const sessions = {
-        embed_tokens: "embed_tokens",
-        audio_encoder: "audio_encoder",
-        decoder_model_merged: "decoder_model_merged"
-      };
-      info = await Promise.all([
-        constructSessions(pretrained_model_name_or_path, sessions, options, "decoder_model_merged"),
-        get_optional_configs(
-          pretrained_model_name_or_path,
-          {
-            generation_config: "generation_config.json"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.ImageAudioTextToText) {
-      const sessions = {
-        embed_tokens: "embed_tokens",
-        audio_encoder: "audio_encoder",
-        vision_encoder: "vision_encoder",
-        decoder_model_merged: "decoder_model_merged"
-      };
-      info = await Promise.all([
-        constructSessions(pretrained_model_name_or_path, sessions, options),
-        get_optional_configs(
-          pretrained_model_name_or_path,
-          {
-            generation_config: "generation_config.json"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.Musicgen) {
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            model: "text_encoder",
-            decoder_model_merged: "decoder_model_merged",
-            encodec_decode: "encodec_decode"
-          },
-          options,
-          "decoder_model_merged"
-        ),
-        get_optional_configs(
-          pretrained_model_name_or_path,
-          {
-            generation_config: "generation_config.json"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.MultiModality) {
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            prepare_inputs_embeds: "prepare_inputs_embeds",
-            model: "language_model",
-            lm_head: "lm_head",
-            gen_head: "gen_head",
-            gen_img_embeds: "gen_img_embeds",
-            image_decode: "image_decode"
-          },
-          options,
-          "model"
-        ),
-        get_optional_configs(
-          pretrained_model_name_or_path,
-          {
-            generation_config: "generation_config.json"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.Phi3V) {
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            prepare_inputs_embeds: "prepare_inputs_embeds",
-            model: "model",
-            vision_encoder: "vision_encoder"
-          },
-          options,
-          "model"
-        ),
-        get_optional_configs(
-          pretrained_model_name_or_path,
-          {
-            generation_config: "generation_config.json"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.Chatterbox) {
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            embed_tokens: "embed_tokens",
-            speech_encoder: "speech_encoder",
-            model: "language_model",
-            conditional_decoder: "conditional_decoder"
-          },
-          options,
-          "model"
-        ),
-        get_optional_configs(
-          pretrained_model_name_or_path,
-          {
-            generation_config: "generation_config.json"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.AutoEncoder) {
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            encoder_model: "encoder_model",
-            decoder_model: "decoder_model"
-          },
-          options
-        )
-      ]);
-    } else if (modelType === MODEL_TYPES.Supertonic) {
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            text_encoder: "text_encoder",
-            latent_denoiser: "latent_denoiser",
-            voice_decoder: "voice_decoder"
-          },
-          options
-        )
-      ]);
-    } else {
-      if (modelType === void 0) {
-        const type = modelName ?? config?.model_type;
-        if (type !== "custom") {
-          logger.warn(
-            `Model type for '${type}' not found, assuming encoder-only architecture. Please report this at ${GITHUB_ISSUE_URL}.`
-          );
-        }
+    const typeConfig = MODEL_TYPE_CONFIG[modelType] ?? MODEL_TYPE_CONFIG.default;
+    if (modelType === void 0) {
+      const type = modelName ?? config?.model_type;
+      if (type !== "custom") {
+        logger.warn(
+          `Model type for '${type}' not found, assuming encoder-only architecture. Please report this at ${GITHUB_ISSUE_URL}.`
+        );
       }
-      info = await Promise.all([
-        constructSessions(
-          pretrained_model_name_or_path,
-          {
-            model: options.model_file_name ?? "model"
-          },
-          options
-        )
-      ]);
     }
+    const sessions = typeConfig.sessions(config, options);
+    const promises = [
+      constructSessions(pretrained_model_name_or_path, sessions, options, typeConfig.cache_sessions)
+    ];
+    if (typeConfig.optional_configs) {
+      promises.push(get_optional_configs(pretrained_model_name_or_path, typeConfig.optional_configs, options));
+    }
+    const info = await Promise.all(promises);
     return new this(config, ...info);
   }
   /**
@@ -18964,7 +19859,7 @@ var PreTrainedModel = class extends Callable2 {
    * @param {Tensor} [params.inputs=null]
    * @param {number} [params.bos_token_id=null]
    * @param {Record<string, Tensor|number[]>} [params.model_kwargs]
-   * @returns {{inputs_tensor: Tensor, model_inputs: Record<string, Tensor>, model_input_name: string}} The model-specific inputs for generation.
+   * @returns {{inputs_tensor: Tensor, model_inputs: Record<string, Tensor> & {past_key_values?: DynamicCache}, model_input_name: string}} The model-specific inputs for generation.
    */
   _prepare_model_inputs({ inputs, bos_token_id, model_kwargs }) {
     const model_inputs = pick(model_kwargs, this.forward_params);
@@ -19205,11 +20100,12 @@ var PreTrainedModel = class extends Callable2 {
     }
   }
   /**
-   * Returns an object containing past key values from the given decoder results object.
+   * Returns a DynamicCache containing past key values from the given decoder results object.
    *
    * @param {Object} decoderResults The decoder results object.
-   * @param {Object} pastKeyValues The previous past key values.
-   * @returns {Object} An object containing past key values.
+   * @param {DynamicCache} pastKeyValues The previous past key values.
+   * @param {boolean} [disposeEncoderPKVs=false] Whether to dispose encoder past key values.
+   * @returns {DynamicCache} A new DynamicCache containing the updated past key values.
    */
   getPastKeyValues(decoderResults, pastKeyValues, disposeEncoderPKVs = false) {
     const pkvs = /* @__PURE__ */ Object.create(null);
@@ -19230,7 +20126,7 @@ var PreTrainedModel = class extends Callable2 {
         }
       }
     }
-    return pkvs;
+    return new DynamicCache(pkvs);
   }
   /**
    * Returns an object containing attentions from the given model output object.
@@ -19255,8 +20151,8 @@ var PreTrainedModel = class extends Callable2 {
   /**
    * Adds past key values to the decoder feeds object. If pastKeyValues is null, creates new tensors for past key values.
    *
-   * @param {Object} decoderFeeds The decoder feeds object to add past key values to.
-   * @param {Object} pastKeyValues An object containing past key values.
+   * @param {Record<string, any>} decoderFeeds The decoder feeds object to add past key values to.
+   * @param {DynamicCache|null} pastKeyValues The cache containing past key values.
    */
   addPastKeyValues(decoderFeeds, pastKeyValues) {
     if (pastKeyValues) {
@@ -19273,14 +20169,29 @@ var PreTrainedModel = class extends Callable2 {
       }
     }
   }
-  async encode_image({ pixel_values }) {
-    return (await sessionRun(this.sessions["vision_encoder"], { pixel_values })).image_features;
+  /**
+   * Helper function to select valid inputs and run through the appropriate encoder (vision, text, audio) based on the input type.
+   * @param {string} sessionName
+   * @param {Record<string, Tensor>} inputs
+   * @param {string} outputName
+   * @private
+   */
+  async _encode_input(sessionName, inputs, outputName) {
+    if (!Object.hasOwn(this.sessions, sessionName)) {
+      throw new Error(`Model does not have a ${sessionName} session.`);
+    }
+    const session = this.sessions[sessionName];
+    const output = await sessionRun(session, pick(inputs, session.inputNames));
+    return output[outputName];
+  }
+  async encode_image(inputs) {
+    return this._encode_input("vision_encoder", inputs, "image_features");
   }
-  async encode_text({ input_ids }) {
-    return (await sessionRun(this.sessions["embed_tokens"], { input_ids })).inputs_embeds;
+  async encode_text(inputs) {
+    return this._encode_input("embed_tokens", inputs, "inputs_embeds");
   }
-  async encode_audio({ audio_values }) {
-    return (await sessionRun(this.sessions["audio_encoder"], { audio_values })).audio_features;
+  async encode_audio(inputs) {
+    return this._encode_input("audio_encoder", inputs, "audio_features");
   }
 };
 async function seq2seq_forward(self2, model_inputs) {
@@ -19335,6 +20246,9 @@ async function decoder_forward(self2, model_inputs, is_encoder_decoder = false)
     const start_index = ["paligemma", "gemma3_text", "gemma3"].includes(self2.config.model_type) ? 1 : 0;
     new_model_inputs.position_ids = create_position_ids(new_model_inputs, past_key_values, start_index);
   }
+  if (session.inputNames.includes("num_logits_to_keep") && !new_model_inputs.num_logits_to_keep) {
+    new_model_inputs.num_logits_to_keep = new Tensor2("int64", [0n], []);
+  }
   self2.addPastKeyValues(new_model_inputs, past_key_values);
   const fixed = pick(new_model_inputs, session.inputNames);
   return await sessionRun(session, fixed);
@@ -19343,7 +20257,7 @@ async function generic_text_to_text_forward(self2, {
   // Generic parameters:
   encode_function,
   merge_function,
-  modality_input_name,
+  modality_input_names,
   modality_output_name,
   // Produced by the tokenizer/processor:
   input_ids = null,
@@ -19358,38 +20272,54 @@ async function generic_text_to_text_forward(self2, {
   // Additional parameters
   ...kwargs
 }) {
-  const modality_values = kwargs[modality_input_name];
   if (!inputs_embeds) {
     inputs_embeds = await self2.encode_text({ input_ids, ...kwargs });
-    if (modality_values && input_ids.dims[1] !== 1) {
-      const modality_features = await encode_function({
-        // Pass the modality values under its expected key.
-        // The caller knows whether this is audio or image.
-        [modality_input_name]: modality_values,
-        ...kwargs
-      });
-      ({ inputs_embeds, attention_mask } = merge_function({
-        [modality_output_name]: modality_features,
-        inputs_embeds,
-        input_ids,
-        attention_mask
-      }));
-    } else if (past_key_values && modality_values && input_ids.dims[1] === 1) {
-      const target_length = input_ids.dims[1];
-      const past_length = Object.values(past_key_values)[0].dims.at(-2);
-      attention_mask = cat(
-        [
-          ones([input_ids.dims[0], past_length]),
-          attention_mask.slice(null, [attention_mask.dims[1] - target_length, attention_mask.dims[1]])
-        ],
-        1
-      );
+    const modality_values = pick(kwargs, modality_input_names);
+    if (Object.keys(modality_values).length > 0) {
+      if (input_ids.dims[1] !== 1) {
+        const modality_features = await encode_function({
+          // Pass the modality values under its expected key.
+          // The caller knows whether this is audio or image.
+          ...modality_values,
+          ...kwargs
+        });
+        ({ inputs_embeds, attention_mask } = merge_function({
+          [modality_output_name]: modality_features,
+          inputs_embeds,
+          input_ids,
+          attention_mask
+        }));
+      } else if (past_key_values && input_ids.dims[1] === 1) {
+        const target_length = input_ids.dims[1];
+        const past_length = past_key_values.get_seq_length();
+        attention_mask = cat(
+          [
+            ones([input_ids.dims[0], past_length]),
+            attention_mask.slice(null, [attention_mask.dims[1] - target_length, attention_mask.dims[1]])
+          ],
+          1
+        );
+      }
     }
   }
   if (!position_ids) {
-    if (["qwen2_vl", "qwen2_5_vl_text", "qwen3_vl_text", "qwen3_5_text", "qwen3_5_moe_text"].includes(
-      self2.config.model_type
-    )) {
+    if (
+      // Handle special case for qwen vl models
+      [
+        "qwen2_vl",
+        "qwen2_vl_text",
+        "qwen2_5_vl",
+        "qwen2_5_vl_text",
+        "qwen3_vl",
+        "qwen3_vl_text",
+        "qwen3_vl_moe",
+        "qwen3_vl_moe_text",
+        "qwen3_5",
+        "qwen3_5_text",
+        "qwen3_5_moe",
+        "qwen3_5_moe_text"
+      ].includes(self2.config.model_type)
+    ) {
       const { image_grid_thw, video_grid_thw } = kwargs;
       [position_ids] = self2.get_rope_index(input_ids, image_grid_thw, video_grid_thw, attention_mask);
     }
@@ -19411,7 +20341,7 @@ async function generic_text_to_text_forward(self2, {
 async function audio_text_to_text_forward(self2, params) {
   return await generic_text_to_text_forward(self2, {
     ...params,
-    modality_input_name: "audio_values",
+    modality_input_names: ["audio_values", "input_features"],
     modality_output_name: "audio_features",
     encode_function: self2.encode_audio.bind(self2),
     merge_function: self2._merge_input_ids_with_audio_features.bind(self2)
@@ -19420,7 +20350,7 @@ async function audio_text_to_text_forward(self2, params) {
 async function image_text_to_text_forward(self2, params) {
   return await generic_text_to_text_forward(self2, {
     ...params,
-    modality_input_name: "pixel_values",
+    modality_input_names: ["pixel_values"],
     modality_output_name: "image_features",
     encode_function: self2.encode_image.bind(self2),
     merge_function: self2._merge_input_ids_with_image_features.bind(self2)
@@ -19456,7 +20386,11 @@ function create_position_ids(model_inputs, past_key_values = null, start_index =
   return position_ids;
 }
 function decoder_prepare_inputs_for_generation(self2, input_ids, model_inputs, generation_config) {
-  const past_length = model_inputs.past_key_values ? Object.values(model_inputs.past_key_values)[0].dims.at(-2) : 0;
+  const past_length = model_inputs.past_key_values ? model_inputs.past_key_values.get_seq_length() : 0;
+  const session = self2.sessions["decoder_model_merged"] ?? self2.sessions["model"];
+  if (session?.inputNames.includes("num_logits_to_keep") && !model_inputs.num_logits_to_keep) {
+    model_inputs.num_logits_to_keep = new Tensor2("int64", [1n], []);
+  }
   if (!model_inputs.attention_mask) {
     let dims;
     for (const key of ["input_ids", "inputs_embeds", "position_ids"]) {
@@ -19764,6 +20698,7 @@ __export(models_exports, {
   Gemma3ForCausalLM: () => Gemma3ForCausalLM,
   Gemma3Model: () => Gemma3Model,
   Gemma3PreTrainedModel: () => Gemma3PreTrainedModel,
+  Gemma3nForCausalLM: () => Gemma3nForCausalLM,
   Gemma3nForConditionalGeneration: () => Gemma3nForConditionalGeneration,
   Gemma3nPreTrainedModel: () => Gemma3nPreTrainedModel,
   GemmaForCausalLM: () => GemmaForCausalLM,
@@ -19781,6 +20716,7 @@ __export(models_exports, {
   GraniteMoeHybridModel: () => GraniteMoeHybridModel,
   GraniteMoeHybridPreTrainedModel: () => GraniteMoeHybridPreTrainedModel,
   GranitePreTrainedModel: () => GranitePreTrainedModel,
+  GraniteSpeechForConditionalGeneration: () => GraniteSpeechForConditionalGeneration,
   GroundingDinoForObjectDetection: () => GroundingDinoForObjectDetection,
   GroundingDinoPreTrainedModel: () => GroundingDinoPreTrainedModel,
   GroupViTModel: () => GroupViTModel,
@@ -19802,7 +20738,6 @@ __export(models_exports, {
   IJepaModel: () => IJepaModel,
   IJepaPreTrainedModel: () => IJepaPreTrainedModel,
   Idefics3ForConditionalGeneration: () => Idefics3ForConditionalGeneration,
-  Idefics3PreTrainedModel: () => Idefics3PreTrainedModel,
   JAISLMHeadModel: () => JAISLMHeadModel,
   JAISModel: () => JAISModel,
   JAISPreTrainedModel: () => JAISPreTrainedModel,
@@ -19816,6 +20751,7 @@ __export(models_exports, {
   Lfm2MoeModel: () => Lfm2MoeModel,
   Lfm2MoePreTrainedModel: () => Lfm2MoePreTrainedModel,
   Lfm2PreTrainedModel: () => Lfm2PreTrainedModel,
+  Lfm2VlForConditionalGeneration: () => Lfm2VlForConditionalGeneration,
   LiteWhisperForConditionalGeneration: () => LiteWhisperForConditionalGeneration,
   Llama4ForCausalLM: () => Llama4ForCausalLM,
   Llama4PreTrainedModel: () => Llama4PreTrainedModel,
@@ -19940,6 +20876,9 @@ __export(models_exports, {
   Olmo3Model: () => Olmo3Model,
   Olmo3PreTrainedModel: () => Olmo3PreTrainedModel,
   OlmoForCausalLM: () => OlmoForCausalLM,
+  OlmoHybridForCausalLM: () => OlmoHybridForCausalLM,
+  OlmoHybridModel: () => OlmoHybridModel,
+  OlmoHybridPreTrainedModel: () => OlmoHybridPreTrainedModel,
   OlmoModel: () => OlmoModel,
   OlmoPreTrainedModel: () => OlmoPreTrainedModel,
   OpenELMForCausalLM: () => OpenELMForCausalLM,
@@ -19952,7 +20891,6 @@ __export(models_exports, {
   Owlv2Model: () => Owlv2Model,
   Owlv2PreTrainedModel: () => Owlv2PreTrainedModel,
   PaliGemmaForConditionalGeneration: () => PaliGemmaForConditionalGeneration,
-  PaliGemmaPreTrainedModel: () => PaliGemmaPreTrainedModel,
   ParakeetForCTC: () => ParakeetForCTC,
   ParakeetPreTrainedModel: () => ParakeetPreTrainedModel,
   PatchTSMixerForPrediction: () => PatchTSMixerForPrediction,
@@ -19978,15 +20916,31 @@ __export(models_exports, {
   PyAnnotePreTrainedModel: () => PyAnnotePreTrainedModel,
   Qwen2ForCausalLM: () => Qwen2ForCausalLM,
   Qwen2Model: () => Qwen2Model,
+  Qwen2MoeForCausalLM: () => Qwen2MoeForCausalLM,
+  Qwen2MoeModel: () => Qwen2MoeModel,
+  Qwen2MoePreTrainedModel: () => Qwen2MoePreTrainedModel,
   Qwen2PreTrainedModel: () => Qwen2PreTrainedModel,
+  Qwen2VLForCausalLM: () => Qwen2VLForCausalLM,
   Qwen2VLForConditionalGeneration: () => Qwen2VLForConditionalGeneration,
   Qwen2VLPreTrainedModel: () => Qwen2VLPreTrainedModel,
+  Qwen2_5_VLForCausalLM: () => Qwen2_5_VLForCausalLM,
   Qwen2_5_VLForConditionalGeneration: () => Qwen2_5_VLForConditionalGeneration,
   Qwen3ForCausalLM: () => Qwen3ForCausalLM,
   Qwen3Model: () => Qwen3Model,
+  Qwen3MoeForCausalLM: () => Qwen3MoeForCausalLM,
+  Qwen3MoeModel: () => Qwen3MoeModel,
+  Qwen3MoePreTrainedModel: () => Qwen3MoePreTrainedModel,
+  Qwen3NextForCausalLM: () => Qwen3NextForCausalLM,
+  Qwen3NextModel: () => Qwen3NextModel,
+  Qwen3NextPreTrainedModel: () => Qwen3NextPreTrainedModel,
   Qwen3PreTrainedModel: () => Qwen3PreTrainedModel,
+  Qwen3VLForCausalLM: () => Qwen3VLForCausalLM,
   Qwen3VLForConditionalGeneration: () => Qwen3VLForConditionalGeneration,
+  Qwen3VLMoeForCausalLM: () => Qwen3VLMoeForCausalLM,
+  Qwen3VLMoeForConditionalGeneration: () => Qwen3VLMoeForConditionalGeneration,
+  Qwen3_5ForCausalLM: () => Qwen3_5ForCausalLM,
   Qwen3_5ForConditionalGeneration: () => Qwen3_5ForConditionalGeneration,
+  Qwen3_5MoeForCausalLM: () => Qwen3_5MoeForCausalLM,
   Qwen3_5MoeForConditionalGeneration: () => Qwen3_5MoeForConditionalGeneration,
   RFDetrForObjectDetection: () => RFDetrForObjectDetection,
   RFDetrModel: () => RFDetrModel,
@@ -20037,7 +20991,6 @@ __export(models_exports, {
   SmolLM3ForCausalLM: () => SmolLM3ForCausalLM,
   SmolLM3Model: () => SmolLM3Model,
   SmolLM3PreTrainedModel: () => SmolLM3PreTrainedModel,
-  SmolVLMForConditionalGeneration: () => SmolVLMForConditionalGeneration,
   SnacDecoderModel: () => SnacDecoderModel,
   SnacEncoderModel: () => SnacEncoderModel,
   SnacModel: () => SnacModel,
@@ -20109,6 +21062,8 @@ __export(models_exports, {
   VitsModelOutput: () => VitsModelOutput,
   VitsPreTrainedModel: () => VitsPreTrainedModel,
   VoxtralForConditionalGeneration: () => VoxtralForConditionalGeneration,
+  VoxtralRealtimeForConditionalGeneration: () => VoxtralRealtimeForConditionalGeneration,
+  VoxtralRealtimePreTrainedModel: () => VoxtralRealtimePreTrainedModel,
   Wav2Vec2BertForCTC: () => Wav2Vec2BertForCTC,
   Wav2Vec2BertForSequenceClassification: () => Wav2Vec2BertForSequenceClassification,
   Wav2Vec2BertModel: () => Wav2Vec2BertModel,
@@ -20469,7 +21424,7 @@ var ChatterboxModel = class extends ChatterboxPreTrainedModel {
         if (!past_key_values || target_length !== 1) {
           throw new Error("Incorrect state encountered during generation.");
         }
-        const past_length = Object.values(past_key_values)[0].dims.at(-2);
+        const past_length = past_key_values.get_seq_length();
         attention_mask = ones([inputs_embeds.dims[0], past_length + target_length]);
       }
     }
@@ -21499,6 +22454,8 @@ var Gemma3nForConditionalGeneration = class extends Gemma3nPreTrainedModel {
     });
   }
 };
+var Gemma3nForCausalLM = class extends Gemma3nForConditionalGeneration {
+};
 
 // src/models/glm/modeling_glm.js
 var GlmPreTrainedModel = class extends PreTrainedModel {
@@ -21580,6 +22537,28 @@ var GraniteMoeHybridModel = class extends GraniteMoeHybridPreTrainedModel {
 var GraniteMoeHybridForCausalLM = class extends GraniteMoeHybridPreTrainedModel {
 };
 
+// src/models/ultravox/modeling_ultravox.js
+var UltravoxPreTrainedModel = class extends PreTrainedModel {
+  forward_params = ["input_ids", "attention_mask", "position_ids", "audio_values", "past_key_values"];
+};
+var UltravoxModel = class extends UltravoxPreTrainedModel {
+  _merge_input_ids_with_audio_features(kwargs) {
+    const audio_hidden_size = kwargs.audio_features.dims.at(-1);
+    const reshaped_audio_features = kwargs.audio_features.view(-1, audio_hidden_size);
+    return default_merge_input_ids_with_audio_features({
+      // @ts-ignore
+      audio_token_id: this.config.ignore_index ?? this.config.audio_token_id ?? this.config.audio_token_index,
+      ...kwargs,
+      audio_features: reshaped_audio_features
+    });
+  }
+};
+
+// src/models/granite_speech/modeling_granite_speech.js
+var GraniteSpeechForConditionalGeneration = class extends UltravoxModel {
+  forward_params = ["input_ids", "attention_mask", "input_features", "past_key_values"];
+};
+
 // src/models/grounding_dino/modeling_grounding_dino.js
 var GroundingDinoPreTrainedModel = class extends PreTrainedModel {
 };
@@ -21675,17 +22654,38 @@ var HubertForSequenceClassification = class extends Wav2Vec2PreTrainedModel {
     return new SequenceClassifierOutput(await super._call(model_inputs));
   }
 };
-
-// src/models/hunyuan_v1_dense/modeling_hunyuan_v1_dense.js
-var HunYuanDenseV1PreTrainedModel = class extends PreTrainedModel {
-};
-var HunYuanDenseV1Model = class extends HunYuanDenseV1PreTrainedModel {
+
+// src/models/hunyuan_v1_dense/modeling_hunyuan_v1_dense.js
+var HunYuanDenseV1PreTrainedModel = class extends PreTrainedModel {
+};
+var HunYuanDenseV1Model = class extends HunYuanDenseV1PreTrainedModel {
+};
+var HunYuanDenseV1ForCausalLM = class extends HunYuanDenseV1PreTrainedModel {
+};
+
+// src/models/llava/modeling_llava.js
+var LlavaPreTrainedModel = class extends PreTrainedModel {
+  forward_params = ["input_ids", "attention_mask", "pixel_values", "position_ids", "past_key_values"];
+};
+var LlavaForConditionalGeneration = class extends LlavaPreTrainedModel {
+  _merge_input_ids_with_image_features(kwargs) {
+    const vision_hidden_size = kwargs.image_features.dims.at(-1);
+    const reshaped_image_hidden_states = kwargs.image_features.view(-1, vision_hidden_size);
+    return default_merge_input_ids_with_image_features({
+      // @ts-ignore
+      image_token_id: this.config.image_token_index ?? this.config.image_token_id,
+      ...kwargs,
+      image_features: reshaped_image_hidden_states
+    });
+  }
+};
+var Moondream1ForConditionalGeneration = class extends LlavaForConditionalGeneration {
 };
-var HunYuanDenseV1ForCausalLM = class extends HunYuanDenseV1PreTrainedModel {
+var LlavaQwen2ForCausalLM = class extends LlavaForConditionalGeneration {
 };
 
 // src/models/idefics3/modeling_idefics3.js
-var Idefics3PreTrainedModel = class extends PreTrainedModel {
+var Idefics3ForConditionalGeneration = class extends LlavaForConditionalGeneration {
   forward_params = [
     "input_ids",
     "attention_mask",
@@ -21695,24 +22695,6 @@ var Idefics3PreTrainedModel = class extends PreTrainedModel {
     "past_key_values"
   ];
 };
-var Idefics3ForConditionalGeneration = class extends Idefics3PreTrainedModel {
-  async encode_image({ pixel_values, pixel_attention_mask }) {
-    const features = (await sessionRun(this.sessions["vision_encoder"], { pixel_values, pixel_attention_mask })).image_features;
-    return features;
-  }
-  _merge_input_ids_with_image_features(kwargs) {
-    const vision_hidden_size = kwargs.image_features.dims.at(-1);
-    const reshaped_image_hidden_states = kwargs.image_features.view(-1, vision_hidden_size);
-    return default_merge_input_ids_with_image_features({
-      // @ts-ignore
-      image_token_id: this.config.image_token_id,
-      ...kwargs,
-      image_features: reshaped_image_hidden_states
-    });
-  }
-};
-var SmolVLMForConditionalGeneration = class extends Idefics3ForConditionalGeneration {
-};
 
 // src/models/ijepa/modeling_ijepa.js
 var IJepaPreTrainedModel = class extends PreTrainedModel {
@@ -21803,6 +22785,19 @@ var Lfm2MoeModel = class extends Lfm2MoePreTrainedModel {
 var Lfm2MoeForCausalLM = class extends Lfm2MoePreTrainedModel {
 };
 
+// src/models/lfm2_vl/modeling_lfm2_vl.js
+var Lfm2VlForConditionalGeneration = class extends LlavaForConditionalGeneration {
+  forward_params = [
+    "input_ids",
+    "attention_mask",
+    "pixel_values",
+    "pixel_attention_mask",
+    "spatial_shapes",
+    "position_ids",
+    "past_key_values"
+  ];
+};
+
 // src/models/llama/modeling_llama.js
 var LlamaPreTrainedModel = class extends PreTrainedModel {
 };
@@ -21817,27 +22812,6 @@ var Llama4PreTrainedModel = class extends PreTrainedModel {
 var Llama4ForCausalLM = class extends Llama4PreTrainedModel {
 };
 
-// src/models/llava/modeling_llava.js
-var LlavaPreTrainedModel = class extends PreTrainedModel {
-  forward_params = ["input_ids", "attention_mask", "pixel_values", "position_ids", "past_key_values"];
-};
-var LlavaForConditionalGeneration = class extends LlavaPreTrainedModel {
-  _merge_input_ids_with_image_features(kwargs) {
-    const vision_hidden_size = kwargs.image_features.dims.at(-1);
-    const reshaped_image_hidden_states = kwargs.image_features.view(-1, vision_hidden_size);
-    return default_merge_input_ids_with_image_features({
-      // @ts-ignore
-      image_token_id: this.config.image_token_index,
-      ...kwargs,
-      image_features: reshaped_image_hidden_states
-    });
-  }
-};
-var Moondream1ForConditionalGeneration = class extends LlavaForConditionalGeneration {
-};
-var LlavaQwen2ForCausalLM = class extends LlavaForConditionalGeneration {
-};
-
 // src/models/longt5/modeling_longt5.js
 var LongT5PreTrainedModel = class extends PreTrainedModel {
 };
@@ -22547,6 +23521,14 @@ var Olmo3Model = class extends Olmo3PreTrainedModel {
 var Olmo3ForCausalLM = class extends Olmo3PreTrainedModel {
 };
 
+// src/models/olmo_hybrid/modeling_olmo_hybrid.js
+var OlmoHybridPreTrainedModel = class extends PreTrainedModel {
+};
+var OlmoHybridModel = class extends OlmoHybridPreTrainedModel {
+};
+var OlmoHybridForCausalLM = class extends OlmoHybridPreTrainedModel {
+};
+
 // src/models/openelm/modeling_openelm.js
 var OpenELMPreTrainedModel = class extends PreTrainedModel {
 };
@@ -22580,27 +23562,7 @@ var OwlViTForObjectDetection = class extends OwlViTPreTrainedModel {
 };
 
 // src/models/paligemma/modeling_paligemma.js
-var PaliGemmaPreTrainedModel = class extends PreTrainedModel {
-  forward_params = [
-    "input_ids",
-    // 'inputs_embeds',
-    "attention_mask",
-    "pixel_values",
-    "position_ids",
-    "past_key_values"
-  ];
-};
-var PaliGemmaForConditionalGeneration = class extends PaliGemmaPreTrainedModel {
-  _merge_input_ids_with_image_features(kwargs) {
-    const vision_hidden_size = kwargs.image_features.dims.at(-1);
-    const reshaped_image_hidden_states = kwargs.image_features.view(-1, vision_hidden_size);
-    return default_merge_input_ids_with_image_features({
-      // @ts-ignore
-      image_token_id: this.config.image_token_index,
-      ...kwargs,
-      image_features: reshaped_image_hidden_states
-    });
-  }
+var PaliGemmaForConditionalGeneration = class extends LlavaForConditionalGeneration {
 };
 
 // src/models/parakeet/modeling_parakeet.js
@@ -22751,6 +23713,14 @@ var Qwen2Model = class extends Qwen2PreTrainedModel {
 var Qwen2ForCausalLM = class extends Qwen2PreTrainedModel {
 };
 
+// src/models/qwen2_moe/modeling_qwen2_moe.js
+var Qwen2MoePreTrainedModel = class extends PreTrainedModel {
+};
+var Qwen2MoeModel = class extends Qwen2MoePreTrainedModel {
+};
+var Qwen2MoeForCausalLM = class extends Qwen2MoePreTrainedModel {
+};
+
 // src/models/qwen2_vl/modeling_qwen2_vl.js
 var Qwen2VLPreTrainedModel = class extends PreTrainedModel {
   forward_params = [
@@ -22765,6 +23735,9 @@ var Qwen2VLPreTrainedModel = class extends PreTrainedModel {
   ];
 };
 var Qwen2VLForConditionalGeneration = class extends Qwen2VLPreTrainedModel {
+  // NOTE: This is used as the base class for all Qwen VL models and their CausalLM variants.
+  // CausalLM variants (e.g., Qwen2VLForCausalLM) extend this class but load only
+  // embed_tokens + decoder_model_merged (no vision_encoder) via MultimodalLanguageModelOnly type.
   image_grid_thw_name = "grid_thw";
   /**
    * Calculate the 3D rope index based on image and video's temporal, height and width in LLM.
@@ -22954,19 +23927,45 @@ var Qwen2VLForConditionalGeneration = class extends Qwen2VLPreTrainedModel {
         );
       } else {
         model_inputs.pixel_values = null;
-        const delta = BigInt(Object.values(model_inputs.past_key_values)[0].dims.at(-2));
-        const rope_deltas_list = model_inputs.rope_deltas.map((x) => delta + x);
-        model_inputs.position_ids = stack([rope_deltas_list, rope_deltas_list, rope_deltas_list], 0);
+        const past_length = model_inputs.past_key_values.get_seq_length();
+        if (past_length < model_inputs.input_ids.dims[1]) {
+          const [full_position_ids, rope_deltas] = this.get_rope_index(
+            model_inputs.input_ids,
+            model_inputs.image_grid_thw,
+            model_inputs.video_grid_thw,
+            model_inputs.attention_mask
+          );
+          model_inputs.rope_deltas = rope_deltas;
+          model_inputs.position_ids = full_position_ids.slice(null, null, [past_length, null]);
+          model_inputs.input_ids = model_inputs.input_ids.slice(null, [past_length, null]);
+        } else {
+          if (!model_inputs.rope_deltas) {
+            [, model_inputs.rope_deltas] = this.get_rope_index(
+              model_inputs.input_ids,
+              model_inputs.image_grid_thw,
+              model_inputs.video_grid_thw,
+              model_inputs.attention_mask
+            );
+          }
+          const delta = BigInt(past_length);
+          const rope_deltas_list = model_inputs.rope_deltas.map((x) => delta + x);
+          model_inputs.position_ids = stack([rope_deltas_list, rope_deltas_list, rope_deltas_list], 0);
+        }
       }
     }
     return model_inputs;
   }
 };
+var Qwen2VLForCausalLM = class extends Qwen2VLForConditionalGeneration {
+};
 
 // src/models/qwen2_5_vl/modeling_qwen2_5_vl.js
 var Qwen2_5_VLForConditionalGeneration = class extends Qwen2VLForConditionalGeneration {
   image_grid_thw_name = "image_grid_thw";
 };
+var Qwen2_5_VLForCausalLM = class extends Qwen2VLForCausalLM {
+  image_grid_thw_name = "image_grid_thw";
+};
 
 // src/models/qwen3/modeling_qwen3.js
 var Qwen3PreTrainedModel = class extends PreTrainedModel {
@@ -22976,17 +23975,45 @@ var Qwen3Model = class extends Qwen3PreTrainedModel {
 var Qwen3ForCausalLM = class extends Qwen3PreTrainedModel {
 };
 
+// src/models/qwen3_moe/modeling_qwen3_moe.js
+var Qwen3MoePreTrainedModel = class extends PreTrainedModel {
+};
+var Qwen3MoeModel = class extends Qwen3MoePreTrainedModel {
+};
+var Qwen3MoeForCausalLM = class extends Qwen3MoePreTrainedModel {
+};
+
+// src/models/qwen3_next/modeling_qwen3_next.js
+var Qwen3NextPreTrainedModel = class extends PreTrainedModel {
+};
+var Qwen3NextModel = class extends Qwen3NextPreTrainedModel {
+};
+var Qwen3NextForCausalLM = class extends Qwen3NextPreTrainedModel {
+};
+
 // src/models/qwen3_vl/modeling_qwen3_vl.js
 var Qwen3VLForConditionalGeneration = class extends Qwen2_5_VLForConditionalGeneration {
 };
+var Qwen3VLForCausalLM = class extends Qwen2_5_VLForCausalLM {
+};
+
+// src/models/qwen3_vl_moe/modeling_qwen3_vl_moe.js
+var Qwen3VLMoeForConditionalGeneration = class extends Qwen3VLForConditionalGeneration {
+};
+var Qwen3VLMoeForCausalLM = class extends Qwen3VLForCausalLM {
+};
 
 // src/models/qwen3_5/modeling_qwen3_5.js
 var Qwen3_5ForConditionalGeneration = class extends Qwen3VLForConditionalGeneration {
 };
+var Qwen3_5ForCausalLM = class extends Qwen3_5ForConditionalGeneration {
+};
 
 // src/models/qwen3_5_moe/modeling_qwen3_5_moe.js
 var Qwen3_5MoeForConditionalGeneration = class extends Qwen3_5ForConditionalGeneration {
 };
+var Qwen3_5MoeForCausalLM = class extends Qwen3_5ForCausalLM {
+};
 
 // src/models/resnet/modeling_resnet.js
 var ResNetPreTrainedModel = class extends PreTrainedModel {
@@ -23667,25 +24694,6 @@ var TrOCRPreTrainedModel = class extends PreTrainedModel {
 var TrOCRForCausalLM = class extends TrOCRPreTrainedModel {
 };
 
-// src/models/ultravox/modeling_ultravox.js
-var UltravoxPreTrainedModel = class extends PreTrainedModel {
-  forward_params = ["input_ids", "attention_mask", "position_ids", "audio_values", "past_key_values"];
-};
-var UltravoxModel = class extends UltravoxPreTrainedModel {
-  _merge_input_ids_with_audio_features(kwargs) {
-    const audio_hidden_size = kwargs.audio_features.dims.at(-1);
-    const reshaped_audio_features = kwargs.audio_features.view(-1, audio_hidden_size);
-    return default_merge_input_ids_with_audio_features({
-      // @ts-ignore
-      audio_token_id: this.config.ignore_index ?? this.config.audio_token_id,
-      ...kwargs,
-      audio_features: reshaped_audio_features
-    });
-  }
-};
-var VoxtralForConditionalGeneration = class extends UltravoxModel {
-};
-
 // src/models/unispeech/modeling_unispeech.js
 var UniSpeechPreTrainedModel = class extends PreTrainedModel {
 };
@@ -23851,6 +24859,170 @@ var VitsModel = class extends VitsPreTrainedModel {
   }
 };
 
+// src/models/voxtral/modeling_voxtral.js
+var VoxtralForConditionalGeneration = class extends UltravoxModel {
+};
+
+// src/models/voxtral_realtime/modeling_voxtral_realtime.js
+var CONV1_LEFT_PAD = 2;
+var CONV2_LEFT_PAD = 1;
+var states = /* @__PURE__ */ new WeakMap();
+function createEncoderState(model, input_features) {
+  const { text_config, audio_config } = (
+    /** @type {any} */
+    model.config
+  );
+  const encoder_session = model.sessions["audio_encoder"];
+  const { num_mel_bins, hidden_size: enc_hidden_size } = audio_config;
+  const PADDING_CACHE_CHANNELS = num_mel_bins + enc_hidden_size;
+  const enc_kv_cache = new DynamicCache();
+  const enc_dtype = encoder_session?.config?.kv_cache_dtype ?? "float32";
+  const enc_cls = enc_dtype === "float16" ? DataTypeMap.float16 : DataTypeMap.float32;
+  const enc_shapes = getCacheShapes(audio_config, { batch_size: 1 });
+  for (const name in enc_shapes) {
+    const size = enc_shapes[name].reduce((a, b) => a * b, 1);
+    enc_kv_cache[name] = new Tensor2(enc_dtype, new enc_cls(size), enc_shapes[name]);
+  }
+  const enc_padding_cache = new Tensor2(enc_dtype, new enc_cls(PADDING_CACHE_CHANNELS * CONV1_LEFT_PAD), [
+    1,
+    PADDING_CACHE_CHANNELS,
+    CONV1_LEFT_PAD
+  ]);
+  const chunks_iter = input_features[Symbol.asyncIterator]?.() ?? input_features[Symbol.iterator]?.();
+  if (!chunks_iter) {
+    throw new Error("input_features must be iterable or async iterable");
+  }
+  return {
+    encoder_session,
+    enc_kv_cache,
+    enc_padding_cache,
+    enc_past_seq_len: 0,
+    audio_embed_queue: [],
+    audio_embed_total_tokens: 0,
+    audio_queue_offset: 0,
+    audio_consumed: 0,
+    stream_exhausted: false,
+    chunks_iter,
+    text_hidden_size: text_config.hidden_size
+  };
+}
+async function encodeChunk(s, chunk_features) {
+  const audio_seq_len = chunk_features.dims[2];
+  const conv2_output_len = Math.floor((CONV2_LEFT_PAD + audio_seq_len - 3) / 2) + 1;
+  const position_ids = new Tensor2(
+    "int64",
+    BigInt64Array.from({ length: conv2_output_len }, (_, i) => BigInt(s.enc_past_seq_len + i)),
+    [1, conv2_output_len]
+  );
+  const total_seq_len = s.enc_past_seq_len + conv2_output_len;
+  const attention_mask = ones([1, total_seq_len]);
+  const { audio_embeds, present_padding_cache, ...present_cache } = await sessionRun(s.encoder_session, {
+    input_features: chunk_features,
+    attention_mask,
+    position_ids,
+    past_padding_cache: s.enc_padding_cache,
+    ...s.enc_kv_cache
+  });
+  if (s.enc_padding_cache.location === "gpu-buffer") {
+    s.enc_padding_cache.dispose();
+  }
+  s.enc_padding_cache = present_padding_cache;
+  for (const name in present_cache) {
+    if (name.startsWith("present.")) {
+      const pastName = name.replace("present", "past_key_values");
+      const prev = s.enc_kv_cache[pastName];
+      if (prev?.location === "gpu-buffer") {
+        prev.dispose();
+      }
+      s.enc_kv_cache[pastName] = present_cache[name];
+    }
+  }
+  s.enc_past_seq_len = total_seq_len;
+  return audio_embeds;
+}
+async function fillAudioBuffer(s, needed) {
+  while (s.audio_embed_total_tokens < needed && !s.stream_exhausted) {
+    const result = await s.chunks_iter.next();
+    if (result.done) {
+      s.stream_exhausted = true;
+      break;
+    }
+    const new_embeds = await encodeChunk(s, result.value);
+    s.audio_embed_queue.push({ data: new_embeds.data, tokens: new_embeds.dims[1] });
+    s.audio_embed_total_tokens += new_embeds.dims[1];
+  }
+}
+function addAudioEmbeddings(s, inputs_embeds, current_len) {
+  if (s.audio_embed_queue.length === 0) return;
+  const embed_data = inputs_embeds.data;
+  let embed_write_pos = 0;
+  let remaining = current_len;
+  while (remaining > 0 && s.audio_embed_queue.length > 0) {
+    const front = s.audio_embed_queue[0];
+    const available = front.tokens - s.audio_queue_offset;
+    const n = Math.min(remaining, available);
+    const src_offset = s.audio_queue_offset * s.text_hidden_size;
+    for (let i = 0; i < n * s.text_hidden_size; ++i) {
+      embed_data[embed_write_pos * s.text_hidden_size + i] += front.data[src_offset + i];
+    }
+    embed_write_pos += n;
+    remaining -= n;
+    s.audio_queue_offset += n;
+    if (s.audio_queue_offset >= front.tokens) {
+      s.audio_embed_queue.shift();
+      s.audio_queue_offset = 0;
+    }
+  }
+  s.audio_consumed += current_len - remaining;
+}
+var AudioExhaustedCriteria = class extends StoppingCriteria {
+  constructor(enc_state) {
+    super();
+    this._s = enc_state;
+  }
+  _call(input_ids) {
+    const done = this._s.stream_exhausted && this._s.audio_embed_queue.length === 0;
+    return input_ids.map(() => done);
+  }
+};
+var VoxtralRealtimePreTrainedModel = class extends PreTrainedModel {
+  forward_params = ["input_ids", "attention_mask", "position_ids", "past_key_values"];
+};
+var VoxtralRealtimeForConditionalGeneration = class extends VoxtralRealtimePreTrainedModel {
+  async forward({ input_ids, past_key_values, ...kwargs }) {
+    const current_len = input_ids.dims[1];
+    const enc = states.get(this);
+    if (enc) {
+      await fillAudioBuffer(enc, enc.audio_consumed + current_len);
+    }
+    const { inputs_embeds } = await sessionRun(this.sessions["embed_tokens"], { input_ids });
+    if (enc) {
+      addAudioEmbeddings(enc, inputs_embeds, current_len);
+    }
+    const decoder_feeds = { inputs_embeds, ...kwargs };
+    this.addPastKeyValues(decoder_feeds, past_key_values);
+    const session = this.sessions["decoder_model_merged"];
+    const fixed = pick(decoder_feeds, session.inputNames);
+    return await sessionRun(session, fixed);
+  }
+  async generate({ input_features, stopping_criteria: userStoppingCriteria, ...kwargs }) {
+    if (!input_features) {
+      throw new Error("input_features (generator/iterable) must be provided");
+    }
+    const enc_state = createEncoderState(this, input_features);
+    states.set(this, enc_state);
+    const stopping_criteria = new StoppingCriteriaList();
+    stopping_criteria.push(new AudioExhaustedCriteria(enc_state));
+    if (userStoppingCriteria) stopping_criteria.extend(userStoppingCriteria);
+    try {
+      return await super.generate({ ...kwargs, stopping_criteria });
+    } finally {
+      enc_state.enc_kv_cache.dispose();
+      states.delete(this);
+    }
+  }
+};
+
 // src/models/wav2vec2_bert/modeling_wav2vec2_bert.js
 var Wav2Vec2BertPreTrainedModel = class extends PreTrainedModel {
 };
@@ -24475,6 +25647,7 @@ var MODEL_MAPPING_NAMES_DECODER_ONLY = /* @__PURE__ */ new Map([
   ["olmo", "OlmoModel"],
   ["olmo2", "Olmo2Model"],
   ["olmo3", "Olmo3Model"],
+  ["olmo_hybrid", "OlmoHybridModel"],
   ["mobilellm", "MobileLLMModel"],
   ["granite", "GraniteModel"],
   ["granitemoehybrid", "GraniteMoeHybridModel"],
@@ -24488,7 +25661,10 @@ var MODEL_MAPPING_NAMES_DECODER_ONLY = /* @__PURE__ */ new Map([
   ["glm", "GlmModel"],
   ["openelm", "OpenELMModel"],
   ["qwen2", "Qwen2Model"],
+  ["qwen2_moe", "Qwen2MoeModel"],
   ["qwen3", "Qwen3Model"],
+  ["qwen3_moe", "Qwen3MoeModel"],
+  ["qwen3_next", "Qwen3NextModel"],
   ["phi", "PhiModel"],
   ["phi3", "Phi3Model"],
   ["mpt", "MptModel"],
@@ -24496,7 +25672,7 @@ var MODEL_MAPPING_NAMES_DECODER_ONLY = /* @__PURE__ */ new Map([
   ["mistral", "MistralModel"],
   ["ministral", "MinistralModel"],
   ["ministral3", "Ministral3Model"],
-  ["ernie4_5", "Ernie4_5_Model"],
+  ["ernie4_5", "Ernie4_5ForCausalLM"],
   ["starcoder2", "Starcoder2Model"],
   ["falcon", "FalconModel"],
   ["falcon_h1", "FalconH1Model"],
@@ -24590,6 +25766,7 @@ var MODEL_FOR_CAUSAL_LM_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["olmo", "OlmoForCausalLM"],
   ["olmo2", "Olmo2ForCausalLM"],
   ["olmo3", "Olmo3ForCausalLM"],
+  ["olmo_hybrid", "OlmoHybridForCausalLM"],
   ["mobilellm", "MobileLLMForCausalLM"],
   ["granite", "GraniteForCausalLM"],
   ["granitemoehybrid", "GraniteMoeHybridForCausalLM"],
@@ -24599,11 +25776,22 @@ var MODEL_FOR_CAUSAL_LM_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["gemma2", "Gemma2ForCausalLM"],
   ["vaultgemma", "VaultGemmaForCausalLM"],
   ["gemma3_text", "Gemma3ForCausalLM"],
+  ["gemma3", "Gemma3ForCausalLM"],
   ["helium", "HeliumForCausalLM"],
   ["glm", "GlmForCausalLM"],
   ["openelm", "OpenELMForCausalLM"],
   ["qwen2", "Qwen2ForCausalLM"],
+  ["qwen2_moe", "Qwen2MoeForCausalLM"],
   ["qwen3", "Qwen3ForCausalLM"],
+  ["qwen3_moe", "Qwen3MoeForCausalLM"],
+  ["qwen3_next", "Qwen3NextForCausalLM"],
+  ["qwen2_vl", "Qwen2VLForCausalLM"],
+  ["qwen2_5_vl", "Qwen2_5_VLForCausalLM"],
+  ["qwen3_vl", "Qwen3VLForCausalLM"],
+  ["qwen3_vl_moe", "Qwen3VLMoeForCausalLM"],
+  ["qwen3_5", "Qwen3_5ForCausalLM"],
+  ["qwen3_5_moe", "Qwen3_5MoeForCausalLM"],
+  ["gemma3n", "Gemma3nForCausalLM"],
   ["phi", "PhiForCausalLM"],
   ["phi3", "Phi3ForCausalLM"],
   ["mpt", "MptForCausalLM"],
@@ -24612,7 +25800,7 @@ var MODEL_FOR_CAUSAL_LM_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["mistral", "MistralForCausalLM"],
   ["ministral", "MinistralForCausalLM"],
   ["ministral3", "Ministral3ForCausalLM"],
-  ["ernie4_5", "Ernie4_5_ForCausalLM"],
+  ["ernie4_5", "Ernie4_5ForCausalLM"],
   ["starcoder2", "Starcoder2ForCausalLM"],
   ["falcon", "FalconForCausalLM"],
   ["falcon_h1", "FalconH1ForCausalLM"],
@@ -24676,8 +25864,10 @@ var MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["qwen2_vl", "Qwen2VLForConditionalGeneration"],
   ["qwen2_5_vl", "Qwen2_5_VLForConditionalGeneration"],
   ["qwen3_vl", "Qwen3VLForConditionalGeneration"],
+  ["qwen3_vl_moe", "Qwen3VLMoeForConditionalGeneration"],
   ["qwen3_5", "Qwen3_5ForConditionalGeneration"],
   ["qwen3_5_moe", "Qwen3_5MoeForConditionalGeneration"],
+  ["lfm2_vl", "Lfm2VlForConditionalGeneration"],
   ["idefics3", "Idefics3ForConditionalGeneration"],
   ["smolvlm", "SmolVLMForConditionalGeneration"],
   ["paligemma", "PaliGemmaForConditionalGeneration"],
@@ -24686,8 +25876,10 @@ var MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["mistral3", "Mistral3ForConditionalGeneration"]
 ]);
 var MODEL_FOR_AUDIO_TEXT_TO_TEXT_MAPPING_NAMES = /* @__PURE__ */ new Map([
+  ["granite_speech", "GraniteSpeechForConditionalGeneration"],
   ["ultravox", "UltravoxModel"],
-  ["voxtral", "VoxtralForConditionalGeneration"]
+  ["voxtral", "VoxtralForConditionalGeneration"],
+  ["voxtral_realtime", "VoxtralRealtimeForConditionalGeneration"]
 ]);
 var MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["vision-encoder-decoder", "VisionEncoderDecoderModel"]
@@ -24870,24 +26062,37 @@ var CUSTOM_MAPPING = [
     MODEL_TYPES.ImageAudioTextToText
   ],
   ["SupertonicForConditionalGeneration", SupertonicForConditionalGeneration, MODEL_TYPES.Supertonic],
-  ["ChatterboxModel", ChatterboxModel, MODEL_TYPES.Chatterbox]
+  ["ChatterboxModel", ChatterboxModel, MODEL_TYPES.Chatterbox],
+  ["Qwen2VLForCausalLM", Qwen2VLForCausalLM, MODEL_TYPES.MultimodalLanguageModelOnly],
+  ["Qwen2_5_VLForCausalLM", Qwen2_5_VLForCausalLM, MODEL_TYPES.MultimodalLanguageModelOnly],
+  ["Qwen3VLForCausalLM", Qwen3VLForCausalLM, MODEL_TYPES.MultimodalLanguageModelOnly],
+  ["Qwen3VLMoeForCausalLM", Qwen3VLMoeForCausalLM, MODEL_TYPES.MultimodalLanguageModelOnly],
+  ["Qwen3_5ForCausalLM", Qwen3_5ForCausalLM, MODEL_TYPES.MultimodalLanguageModelOnly],
+  ["Qwen3_5MoeForCausalLM", Qwen3_5MoeForCausalLM, MODEL_TYPES.MultimodalLanguageModelOnly],
+  ["Gemma3nForCausalLM", Gemma3nForCausalLM, MODEL_TYPES.MultimodalLanguageModelOnly],
+  [
+    "VoxtralRealtimeForConditionalGeneration",
+    VoxtralRealtimeForConditionalGeneration,
+    MODEL_TYPES.VoxtralRealtime
+  ]
 ];
 for (const [name, model, type] of CUSTOM_MAPPING) {
   MODEL_TYPE_MAPPING.set(name, type);
   MODEL_CLASS_TO_NAME_MAPPING.set(model, name);
   MODEL_NAME_TO_CLASS_MAPPING.set(name, model);
 }
-var CUSTOM_ARCHITECTURES = /* @__PURE__ */ new Map([
+var CUSTOM_ARCHITECTURES_MAPPING = /* @__PURE__ */ new Map([
   ["modnet", MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMES],
   ["birefnet", MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMES],
   ["isnet", MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMES],
   ["ben", MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMES]
 ]);
-for (const [name, mapping] of CUSTOM_ARCHITECTURES.entries()) {
+for (const [name, mapping] of CUSTOM_ARCHITECTURES_MAPPING.entries()) {
   mapping.set(name, "PreTrainedModel");
   MODEL_TYPE_MAPPING.set(name, MODEL_TYPES.EncoderOnly);
   MODEL_NAME_TO_CLASS_MAPPING.set(name, PreTrainedModel);
 }
+var CUSTOM_ARCHITECTURES = new Set(CUSTOM_ARCHITECTURES_MAPPING.keys());
 MODEL_TYPE_MAPPING.set("PreTrainedModel", MODEL_TYPES.EncoderOnly);
 MODEL_CLASS_TO_NAME_MAPPING.set(PreTrainedModel, "PreTrainedModel");
 var MODEL_MAPPINGS = {
@@ -24936,6 +26141,18 @@ var PretrainedMixin = class {
    * the model type is not found in the mapping.
    */
   static BASE_IF_FAIL = false;
+  /**
+   * Check whether this AutoModel class supports a given model type.
+   * @param {string} model_type The model type from config (e.g., 'bert', 'whisper').
+   * @returns {boolean} Whether this class can handle the given model type.
+   */
+  static supports(model_type) {
+    if (!this.MODEL_CLASS_MAPPINGS) return false;
+    for (const mapping of this.MODEL_CLASS_MAPPINGS) {
+      if (mapping.has(model_type)) return true;
+    }
+    return this.BASE_IF_FAIL;
+  }
   /** @type {typeof PreTrainedModel.from_pretrained} */
   static async from_pretrained(pretrained_model_name_or_path, {
     progress_callback = null,
@@ -24967,7 +26184,7 @@ var PretrainedMixin = class {
     if (!this.MODEL_CLASS_MAPPINGS) {
       throw new Error("`MODEL_CLASS_MAPPINGS` not implemented for this type of `AutoClass`: " + this.name);
     }
-    const model_type = options.config.model_type;
+    const { model_type } = options.config;
     for (const MODEL_CLASS_MAPPING of this.MODEL_CLASS_MAPPINGS) {
       let modelInfo = MODEL_CLASS_MAPPING.get(model_type);
       if (!modelInfo) {
@@ -26319,40 +27536,30 @@ Pipeline {
 // src/pipelines/index.js
 var SUPPORTED_TASKS = Object.freeze({
   "text-classification": {
-    tokenizer: AutoTokenizer,
     pipeline: TextClassificationPipeline,
     model: AutoModelForSequenceClassification,
     default: {
-      // TODO: replace with original
-      // "model": "distilbert-base-uncased-finetuned-sst-2-english",
       model: "Xenova/distilbert-base-uncased-finetuned-sst-2-english"
     },
     type: "text"
   },
   "token-classification": {
-    tokenizer: AutoTokenizer,
     pipeline: TokenClassificationPipeline,
     model: AutoModelForTokenClassification,
     default: {
-      // TODO: replace with original
-      // "model": "Davlan/bert-base-multilingual-cased-ner-hrl",
       model: "Xenova/bert-base-multilingual-cased-ner-hrl"
     },
     type: "text"
   },
   "question-answering": {
-    tokenizer: AutoTokenizer,
     pipeline: QuestionAnsweringPipeline,
     model: AutoModelForQuestionAnswering,
     default: {
-      // TODO: replace with original
-      // "model": "distilbert-base-cased-distilled-squad",
       model: "Xenova/distilbert-base-cased-distilled-squad"
     },
     type: "text"
   },
   "fill-mask": {
-    tokenizer: AutoTokenizer,
     pipeline: FillMaskPipeline,
     model: AutoModelForMaskedLM,
     default: {
@@ -26362,40 +27569,30 @@ var SUPPORTED_TASKS = Object.freeze({
     type: "text"
   },
   summarization: {
-    tokenizer: AutoTokenizer,
     pipeline: SummarizationPipeline,
     model: AutoModelForSeq2SeqLM,
     default: {
-      // TODO: replace with original
-      // "model": "sshleifer/distilbart-cnn-6-6",
       model: "Xenova/distilbart-cnn-6-6"
     },
     type: "text"
   },
   translation: {
-    tokenizer: AutoTokenizer,
     pipeline: TranslationPipeline,
     model: AutoModelForSeq2SeqLM,
     default: {
-      // TODO: replace with original
-      // "model": "t5-small",
       model: "Xenova/t5-small"
     },
     type: "text"
   },
   "text2text-generation": {
-    tokenizer: AutoTokenizer,
     pipeline: Text2TextGenerationPipeline,
     model: AutoModelForSeq2SeqLM,
     default: {
-      // TODO: replace with original
-      // "model": "google/flan-t5-small",
       model: "Xenova/flan-t5-small"
     },
     type: "text"
   },
   "text-generation": {
-    tokenizer: AutoTokenizer,
     pipeline: TextGenerationPipeline,
     model: AutoModelForCausalLM,
     default: {
@@ -26405,12 +27602,9 @@ var SUPPORTED_TASKS = Object.freeze({
     type: "text"
   },
   "zero-shot-classification": {
-    tokenizer: AutoTokenizer,
     pipeline: ZeroShotClassificationPipeline,
     model: AutoModelForSequenceClassification,
     default: {
-      // TODO: replace with original
-      // "model": "typeform/distilbert-base-uncased-mnli",
       model: "Xenova/distilbert-base-uncased-mnli"
     },
     type: "text"
@@ -26418,47 +27612,30 @@ var SUPPORTED_TASKS = Object.freeze({
   "audio-classification": {
     pipeline: AudioClassificationPipeline,
     model: AutoModelForAudioClassification,
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "superb/wav2vec2-base-superb-ks",
       model: "Xenova/wav2vec2-base-superb-ks"
     },
     type: "audio"
   },
   "zero-shot-audio-classification": {
-    tokenizer: AutoTokenizer,
     pipeline: ZeroShotAudioClassificationPipeline,
     model: AutoModel,
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "laion/clap-htsat-fused",
       model: "Xenova/clap-htsat-unfused"
     },
     type: "multimodal"
   },
   "automatic-speech-recognition": {
-    tokenizer: AutoTokenizer,
     pipeline: AutomaticSpeechRecognitionPipeline,
     model: [AutoModelForSpeechSeq2Seq, AutoModelForCTC],
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "openai/whisper-tiny.en",
       model: "Xenova/whisper-tiny.en"
     },
     type: "multimodal"
   },
   "text-to-audio": {
-    tokenizer: AutoTokenizer,
     pipeline: TextToAudioPipeline,
     model: [AutoModelForTextToWaveform, AutoModelForTextToSpectrogram],
-    processor: [
-      AutoProcessor,
-      /* Some don't use a processor */
-      null
-    ],
     default: {
       model: "onnx-community/Supertonic-TTS-ONNX",
       dtype: "fp32"
@@ -26466,124 +27643,86 @@ var SUPPORTED_TASKS = Object.freeze({
     type: "text"
   },
   "image-to-text": {
-    tokenizer: AutoTokenizer,
     pipeline: ImageToTextPipeline,
     model: AutoModelForVision2Seq,
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "nlpconnect/vit-gpt2-image-captioning",
       model: "Xenova/vit-gpt2-image-captioning"
     },
     type: "multimodal"
   },
   "image-classification": {
-    // no tokenizer
     pipeline: ImageClassificationPipeline,
     model: AutoModelForImageClassification,
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "google/vit-base-patch16-224",
       model: "Xenova/vit-base-patch16-224"
     },
     type: "multimodal"
   },
   "image-segmentation": {
-    // no tokenizer
     pipeline: ImageSegmentationPipeline,
     model: [AutoModelForImageSegmentation, AutoModelForSemanticSegmentation, AutoModelForUniversalSegmentation],
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "facebook/detr-resnet-50-panoptic",
       model: "Xenova/detr-resnet-50-panoptic"
     },
     type: "multimodal"
   },
   "background-removal": {
-    // no tokenizer
     pipeline: BackgroundRemovalPipeline,
     model: [AutoModelForImageSegmentation, AutoModelForSemanticSegmentation, AutoModelForUniversalSegmentation],
-    processor: AutoProcessor,
     default: {
       model: "Xenova/modnet"
     },
     type: "image"
   },
   "zero-shot-image-classification": {
-    tokenizer: AutoTokenizer,
     pipeline: ZeroShotImageClassificationPipeline,
     model: AutoModel,
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "openai/clip-vit-base-patch32",
       model: "Xenova/clip-vit-base-patch32"
     },
     type: "multimodal"
   },
   "object-detection": {
-    // no tokenizer
     pipeline: ObjectDetectionPipeline,
     model: AutoModelForObjectDetection,
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "facebook/detr-resnet-50",
       model: "Xenova/detr-resnet-50"
     },
     type: "multimodal"
   },
   "zero-shot-object-detection": {
-    tokenizer: AutoTokenizer,
     pipeline: ZeroShotObjectDetectionPipeline,
     model: AutoModelForZeroShotObjectDetection,
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "google/owlvit-base-patch32",
       model: "Xenova/owlvit-base-patch32"
     },
     type: "multimodal"
   },
   "document-question-answering": {
-    tokenizer: AutoTokenizer,
     pipeline: DocumentQuestionAnsweringPipeline,
     model: AutoModelForDocumentQuestionAnswering,
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "naver-clova-ix/donut-base-finetuned-docvqa",
       model: "Xenova/donut-base-finetuned-docvqa"
     },
     type: "multimodal"
   },
   "image-to-image": {
-    // no tokenizer
     pipeline: ImageToImagePipeline,
     model: AutoModelForImageToImage,
-    processor: AutoProcessor,
     default: {
-      // TODO: replace with original
-      // "model": "caidas/swin2SR-classical-sr-x2-64",
       model: "Xenova/swin2SR-classical-sr-x2-64"
     },
     type: "image"
   },
   "depth-estimation": {
-    // no tokenizer
     pipeline: DepthEstimationPipeline,
     model: AutoModelForDepthEstimation,
-    processor: AutoProcessor,
     default: {
       model: "onnx-community/depth-anything-v2-small"
     },
     type: "image"
   },
-  // This task serves as a useful interface for dealing with sentence-transformers (https://huggingface.co/sentence-transformers).
   "feature-extraction": {
-    tokenizer: AutoTokenizer,
     pipeline: FeatureExtractionPipeline,
     model: AutoModel,
     default: {
@@ -26593,7 +27732,6 @@ var SUPPORTED_TASKS = Object.freeze({
     type: "text"
   },
   "image-feature-extraction": {
-    processor: AutoProcessor,
     pipeline: ImageFeatureExtractionPipeline,
     model: [AutoModelForImageFeatureExtraction, AutoModel],
     default: {
@@ -26614,8 +27752,18 @@ var TASK_ALIASES = Object.freeze({
 });
 
 // src/utils/model_registry/get_model_files.js
+function get_config(modelId, { config = null, cache_dir = null, local_files_only = false, revision = "main" } = {}) {
+  if (config !== null) {
+    return AutoConfig.from_pretrained(modelId, { config, cache_dir, local_files_only, revision });
+  }
+  const key = JSON.stringify([modelId, cache_dir, local_files_only, revision]);
+  return memoizePromise(
+    key,
+    () => AutoConfig.from_pretrained(modelId, { config, cache_dir, local_files_only, revision })
+  );
+}
 async function get_model_files(modelId, { config = null, dtype: overrideDtype = null, device: overrideDevice = null, model_file_name = null } = {}) {
-  config = await AutoConfig.from_pretrained(modelId, { config });
+  config = await get_config(modelId, { config });
   const files = [
     // Add config.json (always loaded)
     "config.json"
@@ -26645,6 +27793,15 @@ async function get_model_files(modelId, { config = null, dtype: overrideDtype =
       modelType = mappedType;
       foundInMapping = true;
     }
+    if (!foundInMapping) {
+      for (const mapping of Object.values(MODEL_MAPPING_NAMES)) {
+        if (mapping.has(config.model_type)) {
+          modelType = MODEL_TYPE_MAPPING.get(mapping.get(config.model_type));
+          foundInMapping = true;
+          break;
+        }
+      }
+    }
   }
   if (!foundInMapping) {
     const archList = architectures.length > 0 ? architectures.join(", ") : "(none)";
@@ -26667,74 +27824,14 @@ async function get_model_files(modelId, { config = null, dtype: overrideDtype =
       files.push(dataFilePath);
     }
   };
-  const singleModelName = model_file_name ?? "model";
-  if (modelType === MODEL_TYPES.DecoderOnly) {
-    add_model_file("model", singleModelName);
-    files.push("generation_config.json");
-  } else if (modelType === MODEL_TYPES.DecoderOnlyWithoutHead) {
-    add_model_file("model", singleModelName);
-  } else if (modelType === MODEL_TYPES.Seq2Seq || modelType === MODEL_TYPES.Vision2Seq) {
-    add_model_file("model", "encoder_model");
-    add_model_file("decoder_model_merged");
-    files.push("generation_config.json");
-  } else if (modelType === MODEL_TYPES.MaskGeneration) {
-    add_model_file("model", "vision_encoder");
-    add_model_file("prompt_encoder_mask_decoder");
-  } else if (modelType === MODEL_TYPES.EncoderDecoder) {
-    add_model_file("model", "encoder_model");
-    add_model_file("decoder_model_merged");
-  } else if (modelType === MODEL_TYPES.ImageTextToText) {
-    add_model_file("embed_tokens");
-    add_model_file("vision_encoder");
-    add_model_file("decoder_model_merged");
-    if (config.is_encoder_decoder) {
-      add_model_file("model", "encoder_model");
-    }
-    files.push("generation_config.json");
-  } else if (modelType === MODEL_TYPES.AudioTextToText) {
-    add_model_file("embed_tokens");
-    add_model_file("audio_encoder");
-    add_model_file("decoder_model_merged");
-    files.push("generation_config.json");
-  } else if (modelType === MODEL_TYPES.ImageAudioTextToText) {
-    add_model_file("embed_tokens");
-    add_model_file("audio_encoder");
-    add_model_file("vision_encoder");
-    add_model_file("decoder_model_merged");
-    files.push("generation_config.json");
-  } else if (modelType === MODEL_TYPES.Musicgen) {
-    add_model_file("model", "text_encoder");
-    add_model_file("decoder_model_merged");
-    add_model_file("encodec_decode");
-    files.push("generation_config.json");
-  } else if (modelType === MODEL_TYPES.MultiModality) {
-    add_model_file("prepare_inputs_embeds");
-    add_model_file("model", "language_model");
-    add_model_file("lm_head");
-    add_model_file("gen_head");
-    add_model_file("gen_img_embeds");
-    add_model_file("image_decode");
-    files.push("generation_config.json");
-  } else if (modelType === MODEL_TYPES.Phi3V) {
-    add_model_file("prepare_inputs_embeds");
-    add_model_file("model");
-    add_model_file("vision_encoder");
-    files.push("generation_config.json");
-  } else if (modelType === MODEL_TYPES.Chatterbox) {
-    add_model_file("embed_tokens");
-    add_model_file("speech_encoder");
-    add_model_file("model", "language_model");
-    add_model_file("conditional_decoder");
-    files.push("generation_config.json");
-  } else if (modelType === MODEL_TYPES.AutoEncoder) {
-    add_model_file("encoder_model");
-    add_model_file("decoder_model");
-  } else if (modelType === MODEL_TYPES.Supertonic) {
-    add_model_file("text_encoder");
-    add_model_file("latent_denoiser");
-    add_model_file("voice_decoder");
-  } else {
-    add_model_file("model", singleModelName);
+  const { sessions, optional_configs } = getSessionsConfig(modelType, config, { model_file_name });
+  for (const [sessionKey, baseName] of Object.entries(sessions)) {
+    add_model_file(sessionKey, baseName);
+  }
+  if (optional_configs) {
+    for (const configFile of Object.values(optional_configs)) {
+      files.push(configFile);
+    }
   }
   return files;
 }
@@ -26770,28 +27867,21 @@ async function get_files(modelId, {
 }
 
 // src/utils/model_registry/get_pipeline_files.js
-function get_task_components(task) {
-  const taskConfig = SUPPORTED_TASKS[task];
-  if (!taskConfig) {
-    return null;
-  }
-  return {
-    tokenizer: !!taskConfig.tokenizer,
-    processor: !!taskConfig.processor
-  };
-}
 async function get_pipeline_files(task, modelId, options = {}) {
   task = TASK_ALIASES[task] ?? task;
-  const components = get_task_components(task);
-  if (!components) {
+  const taskConfig = SUPPORTED_TASKS[task];
+  if (!taskConfig) {
     throw new Error(
       `Unsupported pipeline task: ${task}. Must be one of [${Object.keys(SUPPORTED_TASKS).join(", ")}]`
     );
   }
+  const { type } = taskConfig;
+  const include_tokenizer = type !== "audio" && type !== "image";
+  const include_processor = type !== "text";
   return get_files(modelId, {
     ...options,
-    include_tokenizer: components.tokenizer,
-    include_processor: components.processor
+    include_tokenizer,
+    include_processor
   });
 }
 
@@ -26821,12 +27911,12 @@ async function pipeline2(task, model = null, {
       dtype = pipelineInfo.default.dtype;
     }
   }
+  const expected_files = await get_pipeline_files(task, model, {
+    device,
+    dtype
+  });
   let files_loading = {};
   if (progress_callback) {
-    const expected_files = await get_pipeline_files(task, model, {
-      device,
-      dtype
-    });
     const metadata = await Promise.all(expected_files.map(async (file) => get_file_metadata(model, file)));
     metadata.forEach((m, i) => {
       if (m.exists) {
@@ -26872,13 +27962,31 @@ async function pipeline2(task, model = null, {
     model_file_name,
     session_options
   };
-  const classes = /* @__PURE__ */ new Map([
-    ["tokenizer", pipelineInfo.tokenizer],
-    ["model", pipelineInfo.model],
-    ["processor", pipelineInfo.processor]
+  const hasTokenizer = expected_files.includes("tokenizer.json");
+  const hasProcessor = expected_files.includes("preprocessor_config.json");
+  const modelClasses = pipelineInfo.model;
+  let modelPromise;
+  if (Array.isArray(modelClasses)) {
+    const resolvedConfig = config ?? await AutoConfig.from_pretrained(model, pretrainedOptions);
+    const { model_type } = resolvedConfig;
+    const matchedClass = modelClasses.find((cls) => cls.supports(model_type));
+    if (!matchedClass) {
+      throw Error(
+        `Unsupported model type "${model_type}" for task "${task}". None of the candidate model classes support this type.`
+      );
+    }
+    modelPromise = matchedClass.from_pretrained(model, { ...pretrainedOptions, config: resolvedConfig });
+  } else {
+    modelPromise = modelClasses.from_pretrained(model, pretrainedOptions);
+  }
+  const [tokenizer, processor, model_loaded] = await Promise.all([
+    hasTokenizer ? AutoTokenizer.from_pretrained(model, pretrainedOptions) : null,
+    hasProcessor ? AutoProcessor.from_pretrained(model, pretrainedOptions) : null,
+    modelPromise
   ]);
-  const results = await loadItems(classes, model, pretrainedOptions);
-  results.task = task;
+  const results = { task, model: model_loaded };
+  if (tokenizer) results.tokenizer = tokenizer;
+  if (processor) results.processor = processor;
   dispatchCallback(progress_callback, {
     status: "ready",
     task,
@@ -26887,48 +27995,6 @@ async function pipeline2(task, model = null, {
   const pipelineClass = pipelineInfo.pipeline;
   return new pipelineClass(results);
 }
-async function loadItems(mapping, model, pretrainedOptions) {
-  const result = /* @__PURE__ */ Object.create(null);
-  const promises = [];
-  for (const [name, cls] of mapping.entries()) {
-    if (!cls) continue;
-    let promise;
-    if (Array.isArray(cls)) {
-      promise = new Promise(async (resolve, reject) => {
-        let e;
-        for (const c of cls) {
-          if (c === null) {
-            resolve(null);
-            return;
-          }
-          try {
-            resolve(await c.from_pretrained(model, pretrainedOptions));
-            return;
-          } catch (err) {
-            if (err.message?.includes("Unsupported model type")) {
-              e = err;
-            } else if (err.message?.includes("Could not locate file")) {
-              e = err;
-            } else {
-              reject(err);
-              return;
-            }
-          }
-        }
-        reject(e);
-      });
-    } else {
-      promise = cls.from_pretrained(model, pretrainedOptions);
-    }
-    result[name] = promise;
-    promises.push(promise);
-  }
-  await Promise.all(promises);
-  for (const [name, promise] of Object.entries(result)) {
-    result[name] = await promise;
-  }
-  return result;
-}
 
 // src/generation/streamers.js
 var is_chinese_char2 = (cp) => cp >= 19968 && cp <= 40959 || cp >= 13312 && cp <= 19903 || cp >= 131072 && cp <= 173791 || cp >= 173824 && cp <= 177983 || cp >= 177984 && cp <= 178207 || cp >= 178208 && cp <= 183983 || cp >= 63744 && cp <= 64255 || cp >= 194560 && cp <= 195103;
@@ -27216,21 +28282,38 @@ async function load_video(src, { num_frames = null, fps = null } = {}) {
 
 // src/utils/model_registry/is_cached.js
 async function check_files_cache(modelId, files, options = {}) {
-  const cache = await getCache(options?.cache_dir);
-  if (!cache) {
+  const cache2 = await getCache(options?.cache_dir);
+  if (!cache2) {
     const fileStatuses2 = files.map((filename) => ({ file: filename, cached: false }));
     return { allCached: false, files: fileStatuses2 };
   }
   const fileStatuses = await Promise.all(
     files.map(async (filename) => {
-      const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache);
-      const cached = await checkCachedResource(cache, localPath, proposedCacheKey);
+      const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache2);
+      const cached = await checkCachedResource(cache2, localPath, proposedCacheKey);
       return { file: filename, cached: !!cached };
     })
   );
   return { allCached: fileStatuses.every((f) => f.cached), files: fileStatuses };
 }
+async function is_file_cached(modelId, filename, options = {}) {
+  const cache2 = await getCache(options?.cache_dir);
+  if (!cache2) return false;
+  const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache2);
+  return !!await checkCachedResource(cache2, localPath, proposedCacheKey);
+}
 async function is_cached(modelId, options = {}) {
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  if (!await is_file_cached(modelId, "config.json", options)) {
+    return false;
+  }
+  const files = await get_files(modelId, options);
+  const result = await check_files_cache(modelId, files, options);
+  return result.allCached;
+}
+async function is_cached_files(modelId, options = {}) {
   if (!modelId) {
     throw new Error("modelId is required");
   }
@@ -27238,6 +28321,20 @@ async function is_cached(modelId, options = {}) {
   return await check_files_cache(modelId, files, options);
 }
 async function is_pipeline_cached(task, modelId, options = {}) {
+  if (!task) {
+    throw new Error("task is required");
+  }
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  if (!await is_file_cached(modelId, "config.json", options)) {
+    return false;
+  }
+  const files = await get_pipeline_files(task, modelId, options);
+  const result = await check_files_cache(modelId, files, options);
+  return result.allCached;
+}
+async function is_pipeline_cached_files(task, modelId, options = {}) {
   if (!task) {
     throw new Error("task is required");
   }
@@ -27250,26 +28347,26 @@ async function is_pipeline_cached(task, modelId, options = {}) {
 
 // src/utils/model_registry/clear_cache.js
 async function clear_files_from_cache(modelId, files, options = {}) {
-  const cache = await getCache(options?.cache_dir);
-  if (!cache) {
+  const cache2 = await getCache(options?.cache_dir);
+  if (!cache2) {
     return {
       filesDeleted: 0,
       filesCached: 0,
       files: files.map((filename) => ({ file: filename, deleted: false, wasCached: false }))
     };
   }
-  if (!cache.delete) {
+  if (!cache2.delete) {
     throw new Error("Cache does not support delete operation");
   }
   const results = await Promise.all(
     files.map(async (filename) => {
-      const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache);
-      const cached = await checkCachedResource(cache, localPath, proposedCacheKey);
+      const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache2);
+      const cached = await checkCachedResource(cache2, localPath, proposedCacheKey);
       const wasCached = !!cached;
       let deleted = false;
       if (wasCached) {
-        const deletedWithProposed = await cache.delete(proposedCacheKey);
-        const deletedWithLocal = !deletedWithProposed && proposedCacheKey !== localPath ? await cache.delete(localPath) : false;
+        const deletedWithProposed = await cache2.delete(proposedCacheKey);
+        const deletedWithLocal = !deletedWithProposed && proposedCacheKey !== localPath ? await cache2.delete(localPath) : false;
         deleted = deletedWithProposed || deletedWithLocal;
       }
       return { file: filename, deleted, wasCached };
@@ -27386,26 +28483,30 @@ var ModelRegistry = class {
     return get_processor_files(modelId);
   }
   /**
-   * Check if a model and all its required files are cached.
+   * Quickly checks if a model is fully cached by verifying `config.json` is present,
+   * then confirming all required files are cached.
+   * Returns a plain boolean — use `is_cached_files` if you need per-file detail.
    *
    * @param {string} modelId - The model id
    * @param {Object} [options] - Optional parameters
+   * @param {string} [options.cache_dir] - Custom cache directory
+   * @param {string} [options.revision] - Model revision (default: 'main')
+   * @param {import('../../configs.js').PretrainedConfig} [options.config] - Pre-loaded config
    * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
    * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
-   * @returns {Promise<import('./is_cached.js').CacheCheckResult>} Object with allCached boolean and files array with cache status
+   * @returns {Promise<boolean>} Whether all required files are cached
    *
    * @example
-   * const status = await ModelRegistry.is_cached('onnx-community/bert-base-uncased-ONNX');
-   * console.log(status.allCached); // true or false
+   * const cached = await ModelRegistry.is_cached('onnx-community/bert-base-uncased-ONNX');
+   * console.log(cached); // true or false
    */
   static async is_cached(modelId, options = {}) {
     return is_cached(modelId, options);
   }
   /**
-   * Check if all files for a specific pipeline task are cached.
-   * Automatically determines which components are needed based on the task.
+   * Checks if all files for a given model are already cached, with per-file detail.
+   * Automatically determines which files are needed using get_files().
    *
-   * @param {string} task - The pipeline task (e.g., "text-generation", "background-removal")
    * @param {string} modelId - The model id
    * @param {Object} [options] - Optional parameters
    * @param {string} [options.cache_dir] - Custom cache directory
@@ -27416,12 +28517,57 @@ var ModelRegistry = class {
    * @returns {Promise<import('./is_cached.js').CacheCheckResult>} Object with allCached boolean and files array with cache status
    *
    * @example
-   * const status = await ModelRegistry.is_pipeline_cached('text-generation', 'onnx-community/gpt2-ONNX');
+   * const status = await ModelRegistry.is_cached_files('onnx-community/bert-base-uncased-ONNX');
    * console.log(status.allCached); // true or false
+   * console.log(status.files); // [{ file: 'config.json', cached: true }, ...]
+   */
+  static async is_cached_files(modelId, options = {}) {
+    return is_cached_files(modelId, options);
+  }
+  /**
+   * Quickly checks if all files for a specific pipeline task are cached by verifying
+   * `config.json` is present, then confirming all required files are cached.
+   * Returns a plain boolean — use `is_pipeline_cached_files` if you need per-file detail.
+   *
+   * @param {string} task - The pipeline task (e.g., "text-generation", "background-removal")
+   * @param {string} modelId - The model id
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.cache_dir] - Custom cache directory
+   * @param {string} [options.revision] - Model revision (default: 'main')
+   * @param {import('../../configs.js').PretrainedConfig} [options.config] - Pre-loaded config
+   * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
+   * @returns {Promise<boolean>} Whether all required files are cached
+   *
+   * @example
+   * const cached = await ModelRegistry.is_pipeline_cached('text-generation', 'onnx-community/gpt2-ONNX');
+   * console.log(cached); // true or false
    */
   static async is_pipeline_cached(task, modelId, options = {}) {
     return is_pipeline_cached(task, modelId, options);
   }
+  /**
+   * Checks if all files for a specific pipeline task are already cached, with per-file detail.
+   * Automatically determines which components are needed based on the task.
+   *
+   * @param {string} task - The pipeline task (e.g., "text-generation", "background-removal")
+   * @param {string} modelId - The model id
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.cache_dir] - Custom cache directory
+   * @param {string} [options.revision] - Model revision (default: 'main')
+   * @param {import('../../configs.js').PretrainedConfig} [options.config] - Pre-loaded config
+   * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
+   * @returns {Promise<import('./is_cached.js').CacheCheckResult>} Object with allCached boolean and files array with cache status
+   *
+   * @example
+   * const status = await ModelRegistry.is_pipeline_cached_files('text-generation', 'onnx-community/gpt2-ONNX');
+   * console.log(status.allCached); // true or false
+   * console.log(status.files); // [{ file: 'config.json', cached: true }, ...]
+   */
+  static async is_pipeline_cached_files(task, modelId, options = {}) {
+    return is_pipeline_cached_files(task, modelId, options);
+  }
   /**
    * Get metadata for a specific file without downloading it.
    *
@@ -27701,6 +28847,7 @@ export {
   DonutImageProcessor,
   DonutSwinModel,
   DonutSwinPreTrainedModel,
+  DynamicCache,
   EdgeTamModel,
   EfficientNetForImageClassification,
   EfficientNetImageProcessor,
@@ -27773,6 +28920,7 @@ export {
   Gemma3Model,
   Gemma3PreTrainedModel,
   Gemma3nAudioFeatureExtractor,
+  Gemma3nForCausalLM,
   Gemma3nForConditionalGeneration,
   Gemma3nPreTrainedModel,
   Gemma3nProcessor,
@@ -27792,6 +28940,9 @@ export {
   GraniteMoeHybridModel,
   GraniteMoeHybridPreTrainedModel,
   GranitePreTrainedModel,
+  GraniteSpeechFeatureExtractor,
+  GraniteSpeechForConditionalGeneration,
+  GraniteSpeechProcessor,
   GroundingDinoForObjectDetection,
   GroundingDinoImageProcessor,
   GroundingDinoPreTrainedModel,
@@ -27817,7 +28968,6 @@ export {
   IJepaPreTrainedModel,
   Idefics3ForConditionalGeneration,
   Idefics3ImageProcessor,
-  Idefics3PreTrainedModel,
   Idefics3Processor,
   ImageClassificationPipeline,
   ImageFeatureExtractionPipeline,
@@ -27842,6 +28992,9 @@ export {
   Lfm2MoeModel,
   Lfm2MoePreTrainedModel,
   Lfm2PreTrainedModel,
+  Lfm2VlForConditionalGeneration,
+  Lfm2VlImageProcessor,
+  Lfm2VlProcessor,
   LiteWhisperForConditionalGeneration,
   Llama4ForCausalLM,
   Llama4PreTrainedModel,
@@ -28006,6 +29159,9 @@ export {
   Olmo3Model,
   Olmo3PreTrainedModel,
   OlmoForCausalLM,
+  OlmoHybridForCausalLM,
+  OlmoHybridModel,
+  OlmoHybridPreTrainedModel,
   OlmoModel,
   OlmoPreTrainedModel,
   OpenELMForCausalLM,
@@ -28022,7 +29178,6 @@ export {
   Owlv2Model,
   Owlv2PreTrainedModel,
   PaliGemmaForConditionalGeneration,
-  PaliGemmaPreTrainedModel,
   PaliGemmaProcessor,
   ParakeetFeatureExtractor,
   ParakeetForCTC,
@@ -28061,20 +29216,36 @@ export {
   QuestionAnsweringPipeline,
   Qwen2ForCausalLM,
   Qwen2Model,
+  Qwen2MoeForCausalLM,
+  Qwen2MoeModel,
+  Qwen2MoePreTrainedModel,
   Qwen2PreTrainedModel,
   Qwen2Tokenizer,
+  Qwen2VLForCausalLM,
   Qwen2VLForConditionalGeneration,
   Qwen2VLImageProcessor,
   Qwen2VLPreTrainedModel,
   Qwen2VLProcessor,
+  Qwen2_5_VLForCausalLM,
   Qwen2_5_VLForConditionalGeneration,
   Qwen2_5_VLProcessor,
   Qwen3ForCausalLM,
   Qwen3Model,
+  Qwen3MoeForCausalLM,
+  Qwen3MoeModel,
+  Qwen3MoePreTrainedModel,
+  Qwen3NextForCausalLM,
+  Qwen3NextModel,
+  Qwen3NextPreTrainedModel,
   Qwen3PreTrainedModel,
+  Qwen3VLForCausalLM,
   Qwen3VLForConditionalGeneration,
+  Qwen3VLMoeForCausalLM,
+  Qwen3VLMoeForConditionalGeneration,
   Qwen3VLProcessor,
+  Qwen3_5ForCausalLM,
   Qwen3_5ForConditionalGeneration,
+  Qwen3_5MoeForCausalLM,
   Qwen3_5MoeForConditionalGeneration,
   RFDetrForObjectDetection,
   RFDetrModel,
@@ -28146,7 +29317,6 @@ export {
   SmolLM3ForCausalLM,
   SmolLM3Model,
   SmolLM3PreTrainedModel,
-  SmolVLMForConditionalGeneration,
   Idefics3ImageProcessor as SmolVLMImageProcessor,
   Idefics3Processor as SmolVLMProcessor,
   SnacDecoderModel,
@@ -28252,6 +29422,10 @@ export {
   VitsTokenizer,
   VoxtralForConditionalGeneration,
   VoxtralProcessor,
+  VoxtralRealtimeFeatureExtractor,
+  VoxtralRealtimeForConditionalGeneration,
+  VoxtralRealtimePreTrainedModel,
+  VoxtralRealtimeProcessor,
   Wav2Vec2BertForCTC,
   Wav2Vec2BertForSequenceClassification,
   Wav2Vec2BertModel,