@huggingface/transformers 4.0.0-next.4 → 4.0.0-next.6

package/dist/transformers.web.js

@@ -5,32 +5,41 @@ var __export = (target, all) => {
 };
 
 // ignore-modules:node:fs
-var emptyObj = {};
-var node_fs_default = emptyObj;
+var node_fs_default = {};
 
 // ignore-modules:node:path
-var emptyObj2 = {};
-var node_path_default = emptyObj2;
+var node_path_default = {};
 
 // ignore-modules:node:url
-var emptyObj3 = {};
-var node_url_default = emptyObj3;
+var node_url_default = {};
 
 // src/env.js
-var VERSION = "4.0.0-next.4";
-var IS_PROCESS_AVAILABLE = typeof process !== "undefined";
-var IS_NODE_ENV = IS_PROCESS_AVAILABLE && process?.release?.name === "node";
+var VERSION = "4.0.0-next.6";
+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 = 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_CACHE_AVAILABLE = typeof self !== "undefined" && "caches" in self;
+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;
@@ -47,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 */
@@ -62,7 +77,11 @@ var apis = Object.freeze({
   /** Whether the filesystem API is available */
   IS_FS_AVAILABLE,
   /** Whether the path API is available */
-  IS_PATH_AVAILABLE
+  IS_PATH_AVAILABLE,
+  /** Whether the crypto API is 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__ = "./";
@@ -77,6 +96,20 @@ if (RUNNING_LOCALLY) {
 var DEFAULT_CACHE_DIR = RUNNING_LOCALLY ? node_path_default.join(dirname__, "/.cache/") : null;
 var DEFAULT_LOCAL_MODEL_PATH = "/models/";
 var localModelPath = RUNNING_LOCALLY ? node_path_default.join(dirname__, DEFAULT_LOCAL_MODEL_PATH) : DEFAULT_LOCAL_MODEL_PATH;
+var DEFAULT_FETCH = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
+var LogLevel = Object.freeze({
+  /** All messages including debug output (value: 10) */
+  DEBUG: 10,
+  /** Errors, warnings, and info messages (value: 20) */
+  INFO: 20,
+  /** Errors and warnings (value: 30) */
+  WARNING: 30,
+  /** Only error messages (value: 40) */
+  ERROR: 40,
+  /** No logging output (value: 50) */
+  NONE: 50
+});
+var logLevel = LogLevel.WARNING;
 var env = {
   version: VERSION,
   /////////////////// Backends settings ///////////////////
@@ -85,28 +118,132 @@ var env = {
     // onnxruntime-web/onnxruntime-node
     onnx: {}
   },
+  /////////////////// Logging settings ///////////////////
+  get logLevel() {
+    return logLevel;
+  },
+  set logLevel(level) {
+    logLevel = level;
+    env.backends.onnx?.setLogLevel?.(level);
+  },
   /////////////////// Model settings ///////////////////
   allowRemoteModels: true,
   remoteHost: "https://huggingface.co/",
   remotePathTemplate: "{model}/resolve/{revision}/",
-  allowLocalModels: !(IS_BROWSER_ENV || IS_WEBWORKER_ENV),
+  allowLocalModels: !(IS_BROWSER_ENV || IS_WEBWORKER_ENV || IS_DENO_WEB_RUNTIME),
+  // Default to true for non-web environments, false for web environments
   localModelPath,
   useFS: IS_FS_AVAILABLE,
   /////////////////// Cache settings ///////////////////
-  useBrowserCache: IS_WEB_CACHE_AVAILABLE && !IS_DENO_RUNTIME,
+  useBrowserCache: IS_WEB_CACHE_AVAILABLE,
   useFSCache: IS_FS_AVAILABLE,
   cacheDir: DEFAULT_CACHE_DIR,
   useCustomCache: false,
   customCache: null,
   useWasmCache: IS_WEB_CACHE_AVAILABLE || IS_FS_AVAILABLE,
-  cacheKey: "transformers-cache"
+  cacheKey: "transformers-cache",
+  /////////////////// Custom fetch /////////////////////
+  fetch: DEFAULT_FETCH
   //////////////////////////////////////////////////////
 };
 function isEmpty(obj) {
   return Object.keys(obj).length === 0;
 }
 
-// ../../node_modules/.pnpm/@huggingface+tokenizers@0.1.1/node_modules/@huggingface/tokenizers/dist/tokenizers.mjs
+// src/utils/core.js
+function dispatchCallback(progress_callback, data) {
+  if (progress_callback) progress_callback(data);
+}
+function isIntegralNumber(x) {
+  return Number.isInteger(x) || typeof x === "bigint";
+}
+function isNullishDimension(x) {
+  return x === null || x === void 0 || x === -1;
+}
+function calculateDimensions(arr) {
+  const dimensions = [];
+  let current = arr;
+  while (Array.isArray(current)) {
+    dimensions.push(current.length);
+    current = current[0];
+  }
+  return dimensions;
+}
+function mergeArrays(...arrs) {
+  return Array.prototype.concat.apply([], arrs);
+}
+function product(...a) {
+  return a.reduce((a2, b) => a2.flatMap((d) => b.map((e) => [d, e])));
+}
+function calculateReflectOffset(i, w) {
+  return Math.abs((i + w) % (2 * w) - w);
+}
+function pick(o, props) {
+  return Object.assign(
+    {},
+    ...props.map((prop) => {
+      if (o[prop] !== void 0) {
+        return { [prop]: o[prop] };
+      }
+    })
+  );
+}
+function count(arr, value) {
+  let count2 = 0;
+  for (const v of arr) {
+    if (v === value) ++count2;
+  }
+  return count2;
+}
+
+// src/utils/logger.js
+var logger = {
+  /**
+   * Log an error message. Only suppressed when logLevel is NONE.
+   * @param  {...any} args - Arguments to log
+   */
+  error(...args) {
+    if (env.logLevel <= LogLevel.ERROR) {
+      console.error(...args);
+    }
+  },
+  /**
+   * Log a warning message. Shown when logLevel <= WARNING.
+   * @param  {...any} args - Arguments to log
+   */
+  warn(...args) {
+    if (env.logLevel <= LogLevel.WARNING) {
+      console.warn(...args);
+    }
+  },
+  /**
+   * Log an info message. Shown when logLevel <= INFO.
+   * @param  {...any} args - Arguments to log
+   */
+  info(...args) {
+    if (env.logLevel <= LogLevel.INFO) {
+      console.log(...args);
+    }
+  },
+  /**
+   * Log a debug message. Only shown when logLevel is DEBUG.
+   * @param  {...any} args - Arguments to log
+   */
+  debug(...args) {
+    if (env.logLevel <= LogLevel.DEBUG) {
+      console.log(...args);
+    }
+  },
+  /**
+   * Log a message (alias for info). Shown when logLevel <= INFO.
+   * @param  {...any} args - Arguments to log
+   */
+  log(...args) {
+    this.info(...args);
+  }
+};
+
+// ../../node_modules/.pnpm/@huggingface+tokenizers@0.1.2/node_modules/@huggingface/tokenizers/dist/tokenizers.mjs
 var DictionarySplitter = class {
   /**
    * @param dictionary The dictionary of words to use for splitting.
@@ -230,6 +367,14 @@ var PROBLEMATIC_REGEX_MAP = /* @__PURE__ */ new Map([
   // JS doesn't support possessive quantifiers (these are used in recent OpenAI tokenizers).
   ["[^\\r\\n\\p{L}\\p{N}]?+", "[^\\r\\n\\p{L}\\p{N}]?"],
   ["[^\\s\\p{L}\\p{N}]++", "[^\\s\\p{L}\\p{N}]+"],
+  // JS doesn't support atomic groups (these are used in AFMoE tokenizers).
+  ["(?>\\p{Nd}{510})", "(?:\\p{Nd}{510})"],
+  // JS doesn't support stacking quantifiers.
+  // Uncaught SyntaxError: Invalid regular expression: /\p{Nd}{3}+/u: Nothing to repeat
+  ["\\p{Nd}{3}+", "(?:\\p{Nd}{3})+"],
+  // \G is an invalid escape in JS, and in most cases is just used as an optimization.
+  // So, we can safely remove it.
+  ["\\G", ""],
   // Used to override the default (invalid) regex of the bloom pretokenizer.
   // For more information, see https://github.com/huggingface/transformers.js/issues/94
   [` ?[^(\\s|[${BLOOM_SPLIT_CHARS}])]+`, ` ?[^\\s${BLOOM_SPLIT_CHARS}]+`]
@@ -239,6 +384,7 @@ var clean_up_tokenization = (text) => text.replace(/ \./g, ".").replace(/ \?/g,
 var create_pattern = (pattern, invert = true) => {
   if (pattern.Regex !== void 0) {
     let regex = pattern.Regex.replace(/\\([#&~])/g, "$1");
+    regex = regex.replace(/\\A/g, "^").replace(/\\z/g, "$").replace(/\\Z/g, "(?=\\r?\\n?$)");
     for (const [key, value] of PROBLEMATIC_REGEX_MAP) {
       regex = regex.replaceAll(key, value);
     }
@@ -5380,53 +5526,7 @@ var Callable2 = (
   }
 );
 
-// src/utils/core.js
-function dispatchCallback(progress_callback, data) {
-  if (progress_callback) progress_callback(data);
-}
-function isIntegralNumber(x) {
-  return Number.isInteger(x) || typeof x === "bigint";
-}
-function isNullishDimension(x) {
-  return x === null || x === void 0 || x === -1;
-}
-function calculateDimensions(arr) {
-  const dimensions = [];
-  let current = arr;
-  while (Array.isArray(current)) {
-    dimensions.push(current.length);
-    current = current[0];
-  }
-  return dimensions;
-}
-function mergeArrays(...arrs) {
-  return Array.prototype.concat.apply([], arrs);
-}
-function product(...a) {
-  return a.reduce((a2, b) => a2.flatMap((d) => b.map((e) => [d, e])));
-}
-function calculateReflectOffset(i, w) {
-  return Math.abs((i + w) % (2 * w) - w);
-}
-function pick(o, props) {
-  return Object.assign(
-    {},
-    ...props.map((prop) => {
-      if (o[prop] !== void 0) {
-        return { [prop]: o[prop] };
-      }
-    })
-  );
-}
-function count(arr, value) {
-  let count2 = 0;
-  for (const v of arr) {
-    if (v === value) ++count2;
-  }
-  return count2;
-}
-
-// src/utils/hub/files.js
+// src/utils/hub/FileResponse.js
 var CONTENT_TYPE_MAP = {
   txt: "text/plain",
   html: "text/html",
@@ -5537,6 +5637,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.
@@ -5568,13 +5832,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();
@@ -5594,18 +5861,34 @@ 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;
     }
   }
+  /**
+   * Deletes the cache entry for the given request.
+   * @param {string} request
+   * @returns {Promise<boolean>} A Promise that resolves to `true` if the cache entry was deleted, `false` otherwise.
+   */
+  async delete(request) {
+    let filePath = node_path_default.join(this.path, request);
+    try {
+      await node_fs_default.promises.unlink(filePath);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
   // TODO add the rest?
   // addAll(requests: RequestInfo[]): Promise<void>;
-  // delete(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<boolean>;
   // 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>>;
@@ -5669,12 +5952,12 @@ function handleError(status, remoteURL, fatal) {
   const message = ERROR_MAPPING[status] ?? `Error (${status}) occurred while trying to load file`;
   throw Error(`${message}: "${remoteURL}".`);
 }
-async function readResponse(response, progress_callback) {
+async function readResponse(response, progress_callback, expectedSize) {
   const contentLength = response.headers.get("Content-Length");
-  if (contentLength === null) {
-    console.warn("Unable to determine content-length from response headers. Will expand buffer when needed.");
+  let total = contentLength ? parseInt(contentLength, 10) : expectedSize ?? 0;
+  if (contentLength === null && !expectedSize) {
+    logger.warn("Unable to determine content-length from response headers. Will expand buffer when needed.");
   }
-  let total = parseInt(contentLength ?? "0");
   let buffer = new Uint8Array(total);
   let loaded = 0;
   const reader = response.body.getReader();
@@ -5697,6 +5980,20 @@ async function readResponse(response, progress_callback) {
   await read();
   return buffer;
 }
+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/utils/cache.js
 async function getCache(file_cache_dir = null) {
@@ -5719,7 +6016,7 @@ async function getCache(file_cache_dir = null) {
     try {
       cache = await caches.open(env.cacheKey);
     } catch (e) {
-      console.warn("An error occurred while opening the browser cache:", e);
+      logger.warn("An error occurred while opening the browser cache:", e);
     }
   }
   if (!cache && env.useFSCache) {
@@ -5742,16 +6039,109 @@ async function tryCache(cache, ...names) {
   return void 0;
 }
 
+// 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 });
+}
+async function get_file_metadata(path_or_repo_id, filename, options = {}) {
+  const cache = await getCache(options?.cache_dir);
+  const { localPath, remoteURL, proposedCacheKey, validModelId } = buildResourcePaths(
+    path_or_repo_id,
+    filename,
+    options,
+    cache
+  );
+  const cachedResponse = await checkCachedResource(cache, localPath, proposedCacheKey);
+  if (cachedResponse !== void 0 && typeof cachedResponse !== "string") {
+    const size = cachedResponse.headers.get("content-length");
+    const contentType = cachedResponse.headers.get("content-type");
+    return {
+      exists: true,
+      size: size ? parseInt(size, 10) : void 0,
+      contentType: contentType || void 0,
+      fromCache: true
+    };
+  }
+  if (env.allowLocalModels) {
+    const isURL = isValidUrl(localPath, ["http:", "https:"]);
+    if (!isURL) {
+      try {
+        const response = await getFile(localPath);
+        if (typeof response !== "string" && response.status !== 404) {
+          const size = response.headers.get("content-length");
+          const contentType = response.headers.get("content-type");
+          return {
+            exists: true,
+            size: size ? parseInt(size, 10) : void 0,
+            contentType: contentType || void 0,
+            fromCache: false
+          };
+        }
+      } catch (e) {
+      }
+    }
+  }
+  if (env.allowRemoteModels && !options.local_files_only && validModelId) {
+    try {
+      const rangeResponse = await fetch_file_head(remoteURL);
+      if (rangeResponse && rangeResponse.status >= 200 && rangeResponse.status < 300) {
+        let size;
+        const contentType = rangeResponse.headers.get("content-type");
+        if (rangeResponse.status === 206) {
+          const contentRange = rangeResponse.headers.get("content-range");
+          if (contentRange) {
+            const match = contentRange.match(/bytes \d+-\d+\/(\d+)/);
+            if (match) {
+              size = parseInt(match[1], 10);
+            }
+          }
+        } else if (rangeResponse.status === 200) {
+          try {
+            await rangeResponse.body?.cancel();
+          } catch (cancelError) {
+          }
+        }
+        if (size === void 0) {
+          const contentLength = rangeResponse.headers.get("content-length");
+          size = contentLength ? parseInt(contentLength, 10) : void 0;
+        }
+        return {
+          exists: true,
+          size,
+          contentType: contentType || void 0,
+          fromCache: false
+        };
+      }
+    } catch (e) {
+      logger.warn(`Unable to fetch file metadata for "${remoteURL}": ${e}`);
+    }
+  }
+  return { exists: false, fromCache: false };
+}
+
 // src/utils/hub.js
 async function getFile(urlOrPath) {
   if (env.useFS && !isValidUrl(urlOrPath, ["http:", "https:", "blob:"])) {
     return new FileResponse(
       urlOrPath instanceof URL ? urlOrPath.protocol === "file:" ? urlOrPath.pathname : urlOrPath.toString() : urlOrPath
     );
-  } else if (typeof process !== "undefined" && process?.release?.name === "node") {
+  } else {
+    return env.fetch(urlOrPath, {
+      headers: getFetchHeaders(urlOrPath)
+    });
+  }
+}
+function getFetchHeaders(urlOrPath) {
+  const isNode = typeof process !== "undefined" && process?.release?.name === "node";
+  const headers = new Headers();
+  if (isNode) {
     const IS_CI = !!process.env?.TESTING_REMOTELY;
     const version = env.version;
-    const headers = new Headers();
     headers.set("User-Agent", `transformers.js/${version}; is_ci/${IS_CI};`);
     const isHFURL = isValidUrl(urlOrPath, ["http:", "https:"], ["huggingface.co", "hf.co"]);
     if (isHFURL) {
@@ -5760,10 +6150,9 @@ async function getFile(urlOrPath) {
         headers.set("Authorization", `Bearer ${token}`);
       }
     }
-    return fetch(urlOrPath, { headers });
   } else {
-    return fetch(urlOrPath);
   }
+  return headers;
 }
 function buildResourcePaths(path_or_repo_id, filename, options = {}, cache = null) {
   const revision = options.revision ?? "main";
@@ -5823,7 +6212,7 @@ async function storeCachedResource(path_or_repo_id, filename, cache, cacheKey, r
         }
       )
     ).catch((err) => {
-      console.warn(`Unable to add response to browser cache: ${err}.`);
+      logger.warn(`Unable to add response to browser cache: ${err}.`);
     });
   }
 }
@@ -5847,7 +6236,7 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
           response = await getFile(localPath);
           cacheKey = localPath;
         } catch (e) {
-          console.warn(`Unable to load from local path "${localPath}": "${e}"`);
+          logger.warn(`Unable to load from local path "${localPath}": "${e}"`);
         }
       } else if (options.local_files_only) {
         throw new Error(`\`local_files_only=true\`, but attempted to load a remote file from: ${requestURL}.`);
@@ -5906,14 +6295,31 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
           total: buffer.length
         });
       } else {
-        buffer = await readResponse(response, (data) => {
-          dispatchCallback(options.progress_callback, {
-            status: "progress",
-            name: path_or_repo_id,
-            file: filename,
-            ...data
-          });
-        });
+        let expectedSize;
+        const contentLength = response.headers.get("content-length");
+        if (contentLength) {
+          expectedSize = parseInt(contentLength, 10);
+        } else {
+          try {
+            const metadata = await get_file_metadata(path_or_repo_id, filename, options);
+            if (metadata.size) {
+              expectedSize = metadata.size;
+            }
+          } catch (e) {
+          }
+        }
+        buffer = await readResponse(
+          response,
+          (data) => {
+            dispatchCallback(options.progress_callback, {
+              status: "progress",
+              name: path_or_repo_id,
+              file: filename,
+              ...data
+            });
+          },
+          expectedSize
+        );
       }
     }
     result = buffer;
@@ -6760,20 +7166,9 @@ var uint16_to_float32 = /* @__PURE__ */ (function() {
 // ignore-modules:onnxruntime-node
 var onnxruntime_node_exports = {};
 __export(onnxruntime_node_exports, {
-  Readable: () => Readable,
-  createReadStream: () => createReadStream,
-  createWriteStream: () => createWriteStream,
-  default: () => onnxruntime_node_default,
-  pipeline: () => pipeline
+  default: () => onnxruntime_node_default
 });
-var noop = () => {
-};
-var emptyObj4 = {};
-var onnxruntime_node_default = emptyObj4;
-var Readable = { fromWeb: noop };
-var pipeline = noop;
-var createWriteStream = noop;
-var createReadStream = noop;
+var onnxruntime_node_default = {};
 
 // src/backends/onnx.js
 import * as ONNX_WEB from "onnxruntime-web/webgpu";
@@ -6791,9 +7186,9 @@ async function loadAndCacheFile(url) {
       }
     }
   } catch (error) {
-    console.warn(`Failed to load ${fileName} from cache:`, error);
+    logger.warn(`Failed to load ${fileName} from cache:`, error);
   }
-  const response = await fetch(url);
+  const response = await env.fetch(url);
   if (!response.ok) {
     throw new Error(`Failed to fetch ${fileName}: ${response.status} ${response.statusText}`);
   }
@@ -6801,7 +7196,7 @@ async function loadAndCacheFile(url) {
     try {
       await cache.put(url, response.clone());
     } catch (e) {
-      console.warn(`Failed to cache ${fileName}:`, e);
+      logger.warn(`Failed to cache ${fileName}:`, e);
     }
   }
   return response;
@@ -6812,38 +7207,26 @@ async function loadWasmBinary(wasmURL) {
   try {
     return await response.arrayBuffer();
   } catch (error) {
-    console.warn("Failed to read WASM binary:", error);
+    logger.warn("Failed to read WASM binary:", error);
     return null;
   }
 }
 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.replace(/import\.meta\.url/g, `"${baseUrl}"`);
+    code = code.replaceAll("globalThis.process?.versions?.node", "false");
     const blob = new Blob([code], { type: "text/javascript" });
     return URL.createObjectURL(blob);
   } catch (error) {
-    console.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";
@@ -6873,8 +7256,26 @@ var DEVICE_TO_EXECUTION_PROVIDER_MAPPING = Object.freeze({
   "webnn-cpu": { name: "webnn", deviceType: "cpu" }
   // WebNN CPU
 });
-var LOG_LEVELS = ["verbose", "info", "warning", "error", "fatal"];
-var DEFAULT_LOG_LEVEL = 4;
+function getOnnxLogSeverityLevel(logLevel2) {
+  if (logLevel2 <= LogLevel.DEBUG) {
+    return 0;
+  } else if (logLevel2 <= LogLevel.INFO) {
+    return 2;
+  } else if (logLevel2 <= LogLevel.WARNING) {
+    return 3;
+  } else if (logLevel2 <= LogLevel.ERROR) {
+    return 3;
+  } else {
+    return 4;
+  }
+}
+var ONNX_LOG_LEVEL_NAMES = {
+  0: "verbose",
+  1: "info",
+  2: "warning",
+  3: "error",
+  4: "fatal"
+};
 var supportedDevices = [];
 var defaultDevices;
 var ONNX;
@@ -6924,7 +7325,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() {
@@ -6933,6 +7333,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;
   }
@@ -6941,6 +7346,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 () => {
@@ -6948,12 +7354,13 @@ async function ensureWasmLoaded() {
           const wasmBinary = await loadWasmBinary(toAbsoluteURL(urls.wasm));
           if (wasmBinary) {
             ONNX_ENV.wasm.wasmBinary = wasmBinary;
+            wasmBinaryLoaded = true;
           }
         } catch (err) {
-          console.warn("Failed to pre-load WASM binary:", 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));
@@ -6961,58 +7368,70 @@ async function ensureWasmLoaded() {
             ONNX_ENV.wasm.wasmPaths.mjs = wasmFactoryBlob;
           }
         } catch (err) {
-          console.warn("Failed to pre-load WASM factory:", err);
+          logger.warn("Failed to pre-load WASM factory:", err);
         }
       })() : Promise.resolve()
     ]);
+    if (!wasmBinaryLoaded) {
+      ONNX_ENV.wasm.wasmPaths.mjs = urls.mjs;
+    }
   })();
   return wasmLoadPromise;
 }
 async function createInferenceSession(buffer_or_path, session_options, session_config) {
   await ensureWasmLoaded();
+  const logSeverityLevel = getOnnxLogSeverityLevel(env.logLevel ?? LogLevel.WARNING);
   const load = () => InferenceSession.create(buffer_or_path, {
-    // Set default log level, but allow overriding through session options
-    logSeverityLevel: DEFAULT_LOG_LEVEL,
+    // Set default log severity level, but allow overriding through session options
+    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;
-ONNX_ENV.logLevel = LOG_LEVELS[DEFAULT_LOG_LEVEL];
-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;
 }
-env.backends.onnx = ONNX_ENV;
+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
+  };
+}
 
 // src/ops/registry.js
 var wrap = async (session_bytes, session_options, names) => {
@@ -8099,6 +8518,16 @@ var DEVICE_TYPES = Object.freeze({
   "webnn-cpu": "webnn-cpu"
   // WebNN CPU
 });
+var DEFAULT_DEVICE = apis.IS_NODE_ENV ? "cpu" : "wasm";
+function selectDevice(deviceConfig, fileName, { warn } = {}) {
+  if (!deviceConfig) return DEFAULT_DEVICE;
+  if (typeof deviceConfig === "string") return deviceConfig;
+  if (deviceConfig.hasOwnProperty(fileName)) return deviceConfig[fileName];
+  if (warn) {
+    warn(`device not specified for "${fileName}". Using the default device (${DEFAULT_DEVICE}).`);
+  }
+  return DEFAULT_DEVICE;
+}
 
 // src/utils/dtypes.js
 var isWebGpuFp16Supported = /* @__PURE__ */ (function() {
@@ -8132,6 +8561,7 @@ var DATA_TYPES = Object.freeze({
   q4f16: "q4f16"
   // fp16 model with int4 block weight quantization
 });
+var DEFAULT_DEVICE_DTYPE = DATA_TYPES.fp32;
 var DEFAULT_DEVICE_DTYPE_MAPPING = Object.freeze({
   // NOTE: If not specified, will default to fp32
   [DEVICE_TYPES.wasm]: DATA_TYPES.q8
@@ -8146,6 +8576,45 @@ var DEFAULT_DTYPE_SUFFIX_MAPPING = Object.freeze({
   [DATA_TYPES.q4f16]: "_q4f16",
   [DATA_TYPES.bnb4]: "_bnb4"
 });
+function selectDtype(dtype, fileName, selectedDevice, { configDtype = null, warn } = {}) {
+  let resolved;
+  let needsWarn = false;
+  if (dtype && typeof dtype !== "string") {
+    if (dtype.hasOwnProperty(fileName)) {
+      resolved = dtype[fileName];
+    } else {
+      resolved = null;
+      needsWarn = true;
+    }
+  } else {
+    resolved = /** @type {string|null|undefined} */
+    dtype;
+  }
+  let result;
+  if (resolved === DATA_TYPES.auto) {
+    if (configDtype) {
+      const fallback = typeof configDtype === "string" ? configDtype : configDtype?.[fileName];
+      if (fallback && fallback !== DATA_TYPES.auto && DATA_TYPES.hasOwnProperty(fallback)) {
+        return (
+          /** @type {DataType} */
+          fallback
+        );
+      }
+    }
+    result = DEFAULT_DEVICE_DTYPE_MAPPING[selectedDevice] ?? DEFAULT_DEVICE_DTYPE;
+  } else if (resolved && DATA_TYPES.hasOwnProperty(resolved)) {
+    result = /** @type {DataType} */
+    resolved;
+  } else {
+    result = DEFAULT_DEVICE_DTYPE_MAPPING[selectedDevice] ?? DEFAULT_DEVICE_DTYPE;
+  }
+  if (needsWarn && warn) {
+    warn(
+      `dtype not specified for "${fileName}". Using the default dtype (${result}) for this device (${selectedDevice}).`
+    );
+  }
+  return result;
+}
 var DataTypeMap = Object.freeze({
   float32: Float32Array,
   // @ts-ignore ts(2552) Limited availability of Float16Array across browsers:
@@ -9297,24 +9766,17 @@ function rand(size) {
   const length = size.reduce((a, b) => a * b, 1);
   return new Tensor2(
     "float32",
-    Float32Array.from({ length }, () => Math.random()),
+    Float32Array.from({ length }, () => random.random()),
     size
   );
 }
 function randn(size) {
   const length = size.reduce((a, b) => a * b, 1);
-  const data = new Float32Array(length);
-  for (let i = 0; i < length; i += 2) {
-    const u = 1 - Math.random();
-    const v = Math.random();
-    const mag = Math.sqrt(-2 * Math.log(u));
-    const angle = 2 * Math.PI * v;
-    data[i] = mag * Math.cos(angle);
-    if (i + 1 < length) {
-      data[i + 1] = mag * Math.sin(angle);
-    }
-  }
-  return new Tensor2("float32", data, size);
+  return new Tensor2(
+    "float32",
+    Float32Array.from({ length }, () => random.gauss()),
+    size
+  );
 }
 function quantize_embeddings(tensor, precision) {
   if (tensor.dims.length !== 2) {
@@ -9343,13 +9805,24 @@ function quantize_embeddings(tensor, precision) {
   return new Tensor2(dtype, outputData, [tensor.dims[0], tensor.dims[1] / 8]);
 }
 
+// src/utils/model_registry/get_tokenizer_files.js
+async function get_tokenizer_files(modelId) {
+  if (!modelId) {
+    throw new Error("modelId is required for get_tokenizer_files");
+  }
+  const metadata = await get_file_metadata(modelId, "tokenizer_config.json", {});
+  if (metadata.exists) {
+    return ["tokenizer.json", "tokenizer_config.json"];
+  }
+  return [];
+}
+
 // src/tokenization_utils.js
 async function loadTokenizer(pretrained_model_name_or_path, options) {
-  const info = await Promise.all([
-    getModelJSON(pretrained_model_name_or_path, "tokenizer.json", true, options),
-    getModelJSON(pretrained_model_name_or_path, "tokenizer_config.json", true, options)
-  ]);
-  return info;
+  const tokenizerFiles = await get_tokenizer_files(pretrained_model_name_or_path);
+  return await Promise.all(
+    tokenizerFiles.map((file) => getModelJSON(pretrained_model_name_or_path, file, true, options))
+  );
 }
 function prepareTensorForDecode(tensor) {
   const dims = tensor.dims;
@@ -9523,10 +9996,10 @@ var PreTrainedTokenizer = class extends Callable2 {
    * @param {string|string[]} [options.text_pair=null] Optional second sequence to be encoded. If set, must be the same type as text.
    * @param {boolean|'max_length'} [options.padding=false] Whether to pad the input sequences.
    * @param {boolean} [options.add_special_tokens=true] Whether or not to add the special tokens associated with the corresponding model.
-   * @param {boolean} [options.truncation=null] Whether to truncate the input sequences.
-   * @param {number} [options.max_length=null] Maximum length of the returned list and optionally padding length.
+   * @param {boolean|null} [options.truncation=null] Whether to truncate the input sequences.
+   * @param {number|null} [options.max_length=null] Maximum length of the returned list and optionally padding length.
    * @param {boolean} [options.return_tensor=true] Whether to return the results as Tensors or arrays.
-   * @param {boolean} [options.return_token_type_ids=null] Whether to return the token type ids.
+   * @param {boolean|null} [options.return_token_type_ids=null] Whether to return the token type ids.
    * @returns {BatchEncoding} Object to be passed to the model.
    */
   _call(text, {
@@ -9572,12 +10045,12 @@ var PreTrainedTokenizer = class extends Callable2 {
       max_length = this.model_max_length;
     } else if (truncation === null) {
       if (padding === true) {
-        console.warn(
+        logger.warn(
           "`max_length` is ignored when `padding: true` and there is no truncation strategy. To pad to max length, use `padding: 'max_length'`."
         );
         max_length = this.model_max_length;
       } else if (padding === false) {
-        console.warn(
+        logger.warn(
           "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation: true` to explicitly truncate examples to max length."
         );
         truncation = true;
@@ -9661,9 +10134,9 @@ var PreTrainedTokenizer = class extends Callable2 {
    *
    * @param {string} text The text to encode.
    * @param {Object} options An optional object containing the following properties:
-   * @param {string} [options.text_pair=null] The optional second text to encode.
+   * @param {string|null} [options.text_pair=null] The optional second text to encode.
    * @param {boolean} [options.add_special_tokens=true] Whether or not to add the special tokens associated with the corresponding model.
-   * @param {boolean} [options.return_token_type_ids=null] Whether to return token_type_ids.
+   * @param {boolean|null} [options.return_token_type_ids=null] Whether to return token_type_ids.
    * @returns {{input_ids: number[], attention_mask: number[], token_type_ids?: number[]}} An object containing the encoded text.
    * @private
    */
@@ -9683,7 +10156,7 @@ var PreTrainedTokenizer = class extends Callable2 {
    * Converts a string into a sequence of tokens.
    * @param {string} text The sequence to be encoded.
    * @param {Object} options An optional object containing the following properties:
-   * @param {string} [options.pair] A second sequence to be encoded with the first.
+   * @param {string|null} [options.pair] A second sequence to be encoded with the first.
    * @param {boolean} [options.add_special_tokens=false] Whether or not to add the special tokens associated with the corresponding model.
    * @returns {string[]} The list of tokens.
    */
@@ -9695,9 +10168,9 @@ var PreTrainedTokenizer = class extends Callable2 {
    *
    * @param {string} text The text to encode.
    * @param {Object} options An optional object containing the following properties:
-   * @param {string} [options.text_pair=null] The optional second text to encode.
+   * @param {string|null} [options.text_pair=null] The optional second text to encode.
    * @param {boolean} [options.add_special_tokens=true] Whether or not to add the special tokens associated with the corresponding model.
-   * @param {boolean} [options.return_token_type_ids=null] Whether to return token_type_ids.
+   * @param {boolean|null} [options.return_token_type_ids=null] Whether to return token_type_ids.
    * @returns {number[]} An array of token IDs representing the encoded text(s).
    */
   encode(text, { text_pair = null, add_special_tokens = true, return_token_type_ids = null } = {}) {
@@ -9744,7 +10217,7 @@ var PreTrainedTokenizer = class extends Callable2 {
    * @param {number[]|bigint[]} token_ids List of token ids to decode
    * @param {Object} decode_args Optional arguments for decoding
    * @param {boolean} [decode_args.skip_special_tokens=false] Whether to skip special tokens during decoding
-   * @param {boolean} [decode_args.clean_up_tokenization_spaces=null] Whether to clean up tokenization spaces during decoding.
+   * @param {boolean|null} [decode_args.clean_up_tokenization_spaces=null] Whether to clean up tokenization spaces during decoding.
    * If null, the value is set to `this.decoder.cleanup` if it exists, falling back to `this.clean_up_tokenization_spaces` if it exists, falling back to `true`.
    * @returns {string} The decoded string
    */
@@ -9760,7 +10233,7 @@ var PreTrainedTokenizer = class extends Callable2 {
    * template for better generation tracking.
    *
    * @param {Object} options An optional object containing the following properties:
-   * @param {string} [options.chat_template=null]
+   * @param {string|null} [options.chat_template=null]
    * A Jinja template or the name of a template to use for this conversion.
    * It is usually not necessary to pass anything to this argument,
    * as the model's template will be used by default.
@@ -9829,7 +10302,7 @@ var PreTrainedTokenizer = class extends Callable2 {
    * @param {Message[]} conversation A list of message objects with `"role"` and `"content"` keys,
    * representing the chat history so far.
    * @param {Object} options An optional object containing the following properties:
-   * @param {string} [options.chat_template=null] A Jinja template to use for this conversion. If
+   * @param {string|null} [options.chat_template=null] A Jinja template to use for this conversion. If
    * this is not passed, the model's chat template will be used instead.
    * @param {Object[]} [options.tools=null]
    * A list of tools (callable functions) that will be accessible to the model. If the template does not
@@ -9850,7 +10323,7 @@ var PreTrainedTokenizer = class extends Callable2 {
    * @param {boolean} [options.tokenize=true] Whether to tokenize the output. If false, the output will be a string.
    * @param {boolean} [options.padding=false] Whether to pad sequences to the maximum length. Has no effect if tokenize is false.
    * @param {boolean} [options.truncation=false] Whether to truncate sequences to the maximum length. Has no effect if tokenize is false.
-   * @param {number} [options.max_length=null] Maximum length (in tokens) to use for padding or truncation. Has no effect if tokenize is false.
+   * @param {number|null} [options.max_length=null] Maximum length (in tokens) to use for padding or truncation. Has no effect if tokenize is false.
    * If not specified, the tokenizer's `max_length` attribute will be used as a default.
    * @param {boolean} [options.return_tensor=true] Whether to return the output as a Tensor or an Array. Has no effect if tokenize is false.
    * @param {boolean} [options.return_dict=true] Whether to return a dictionary with named outputs. Has no effect if tokenize is false.
@@ -10128,7 +10601,7 @@ var MarianTokenizer = class extends PreTrainedTokenizer {
     super(tokenizerJSON, tokenizerConfig);
     this.languageRegex = /^(>>\w+<<)\s*/g;
     this.supported_language_codes = Array.from(this.get_vocab().keys()).filter((x) => this.languageRegex.test(x));
-    console.warn(
+    logger.warn(
       'WARNING: `MarianTokenizer` is not yet supported by Hugging Face\'s "fast" tokenizers library. Therefore, you may experience slightly inaccurate results.'
     );
   }
@@ -10148,7 +10621,7 @@ var MarianTokenizer = class extends PreTrainedTokenizer {
     } else if (remainder.length === 2) {
       const [language, text2] = remainder;
       if (!this.supported_language_codes.includes(language)) {
-        console.warn(
+        logger.warn(
           `Unsupported language code "${language}" detected, which may lead to unexpected behavior. Should be one of: ${JSON.stringify(this.supported_language_codes)}`
         );
       }
@@ -10865,7 +11338,7 @@ var XLMTokenizer = class extends PreTrainedTokenizer {
   return_token_type_ids = true;
   constructor(tokenizerJSON, tokenizerConfig) {
     super(tokenizerJSON, tokenizerConfig);
-    console.warn(
+    logger.warn(
       'WARNING: `XLMTokenizer` is not yet supported by Hugging Face\'s "fast" tokenizers library. Therefore, you may experience slightly inaccurate results.'
     );
   }
@@ -10899,7 +11372,7 @@ var AutoTokenizer = class {
     const tokenizerName = tokenizerConfig.tokenizer_class?.replace(/Fast$/, "") ?? "PreTrainedTokenizer";
     let cls = tokenizers_exports[tokenizerName];
     if (!cls) {
-      console.warn(`Unknown tokenizer class "${tokenizerName}", attempting to construct from base class.`);
+      logger.warn(`Unknown tokenizer class "${tokenizerName}", attempting to construct from base class.`);
       cls = PreTrainedTokenizer;
     }
     return new cls(tokenizerJSON, tokenizerConfig);
@@ -11048,6 +11521,8 @@ __export(processors_exports, {
   Processor: () => Processor,
   PyAnnoteProcessor: () => PyAnnoteProcessor,
   Qwen2VLProcessor: () => Qwen2VLProcessor,
+  Qwen2_5_VLProcessor: () => Qwen2_5_VLProcessor,
+  Qwen3VLProcessor: () => Qwen3VLProcessor,
   Sam2Processor: () => Sam2Processor,
   Sam2VideoProcessor: () => Sam2VideoProcessor,
   SamProcessor: () => SamProcessor,
@@ -11122,14 +11597,14 @@ __export(feature_extractors_exports, {
 });
 
 // ignore-modules:node:stream
-var noop2 = () => {
+var noop = () => {
 };
-var Readable2 = { fromWeb: noop2 };
+var Readable = { fromWeb: noop };
 
 // ignore-modules:node:stream/promises
-var noop3 = () => {
+var noop2 = () => {
 };
-var pipeline2 = noop3;
+var pipeline = noop2;
 
 // src/utils/io.js
 async function saveBlob(path, blob) {
@@ -11146,9 +11621,9 @@ async function saveBlob(path, blob) {
     URL.revokeObjectURL(dataURL);
   } else if (apis.IS_FS_AVAILABLE) {
     const webStream = blob.stream();
-    const nodeStream = Readable2.fromWeb(webStream);
+    const nodeStream = Readable.fromWeb(webStream);
     const fileStream = node_fs_default.createWriteStream(path);
-    await pipeline2(nodeStream, fileStream);
+    await pipeline(nodeStream, fileStream);
   } else {
     throw new Error("Unable to save because filesystem is disabled in this environment.");
   }
@@ -11164,7 +11639,7 @@ async function read_audio(url, sampling_rate) {
   const response = await (await getFile(url)).arrayBuffer();
   const audioCTX = new AudioContext({ sampleRate: sampling_rate });
   if (typeof sampling_rate === "undefined") {
-    console.warn(`No sampling rate provided, using default of ${audioCTX.sampleRate}Hz.`);
+    logger.warn(`No sampling rate provided, using default of ${audioCTX.sampleRate}Hz.`);
   }
   const decoded = await audioCTX.decodeAudioData(response);
   let audio;
@@ -11820,7 +12295,7 @@ var ClapFeatureExtractor = class extends FeatureExtractor {
     if (diff > 0) {
       if (truncation === "rand_trunc") {
         longer = true;
-        const idx = Math.floor(Math.random() * (diff + 1));
+        const idx = Math.floor(random.random() * (diff + 1));
         waveform = waveform.subarray(idx, idx + max_length);
         input_mel = await this._extract_fbank_features(
           waveform,
@@ -12553,7 +13028,7 @@ var WhisperFeatureExtractor = class extends FeatureExtractor {
     const length = max_length ?? this.config.n_samples;
     if (audio.length > length) {
       if (audio.length > this.config.n_samples) {
-        console.warn(
+        logger.warn(
           "Attempting to extract features for audio longer than 30 seconds. If using a pipeline to extract transcript from a long audio clip, remember to specify `chunk_length_s` and/or `stride_length_s`."
         );
       }
@@ -12600,18 +13075,16 @@ var ChatterboxProcessor = class extends Processor {
 };
 
 // ignore-modules:sharp
-var emptyObj5 = {};
-var sharp_default = emptyObj5;
+var sharp_default = {};
 
 // src/utils/image.js
 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);
   };
@@ -12701,7 +13174,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 = (
@@ -12730,7 +13203,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);
@@ -12911,7 +13384,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");
@@ -12924,7 +13397,7 @@ var RawImage = class _RawImage {
         case "box":
         case "hamming":
           if (resampleMethod === "box" || resampleMethod === "hamming") {
-            console.warn(
+            logger.warn(
               `Resampling method ${resampleMethod} is not yet supported. Using bilinear instead.`
             );
             resampleMethod = "bilinear";
@@ -12959,7 +13432,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;
@@ -12983,7 +13456,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");
@@ -13011,7 +13484,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");
@@ -13089,7 +13562,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();
@@ -13106,7 +13579,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();
@@ -13190,7 +13663,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.");
       }
@@ -13210,7 +13683,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, {
@@ -13423,30 +13896,9 @@ 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) {
-    console.warn("`label_ids_to_fuse` unset. No instance will be fused.");
+    logger.warn("`label_ids_to_fuse` unset. No instance will be fused.");
     label_ids_to_fuse = /* @__PURE__ */ new Set();
   }
   const class_queries_logits = outputs.class_queries_logits ?? outputs.logits;
@@ -13713,9 +14165,6 @@ var ImageProcessor = class extends Callable2 {
       return [newWidth, newHeight];
     } else if (this.size_divisibility !== void 0) {
       return enforce_size_divisibility([srcWidth, srcHeight], this.size_divisibility);
-    } else if (this.min_pixels !== void 0 && this.max_pixels !== void 0) {
-      const factor = this.config.patch_size * this.config.merge_size;
-      return smart_resize(srcHeight, srcWidth, factor, this.min_pixels, this.max_pixels);
     } else {
       throw new Error(
         `Could not resize image due to unsupported \`this.size\` option in config: ${JSON.stringify(size)}`
@@ -14539,7 +14988,40 @@ 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);
+    this.min_pixels = config.min_pixels ?? config.size?.shortest_edge;
+    this.max_pixels = config.max_pixels ?? config.size?.longest_edge;
+    this.patch_size = config.patch_size;
+    this.merge_size = config.merge_size;
+  }
+  /** @type {ImageProcessor['get_resize_output_image_size']} */
+  get_resize_output_image_size(image, size) {
+    const factor = this.patch_size * this.merge_size;
+    return smart_resize(image.height, image.width, factor, this.min_pixels, this.max_pixels);
+  }
   async _call(images, ...args) {
     const { pixel_values, original_sizes, reshaped_input_sizes } = await super._call(images, ...args);
     let patches = pixel_values;
@@ -14941,7 +15423,7 @@ var AutoImageProcessor = class {
     let image_processor_class = image_processors_exports[key?.replace(/Fast$/, "")];
     if (!image_processor_class) {
       if (key !== void 0) {
-        console.warn(
+        logger.warn(
           `Image processor type '${key}' not found, assuming base ImageProcessor. Please report this at ${GITHUB_ISSUE_URL}.`
         );
       }
@@ -15610,7 +16092,7 @@ var PaliGemmaProcessor = class extends Processor {
   // `images` is required, `text` is optional
   async _call(images, text = null, kwargs = {}) {
     if (!text) {
-      console.warn(
+      logger.warn(
         "You are using PaliGemma without a text prefix. It will perform as a picture-captioning model."
       );
       text = "";
@@ -15632,7 +16114,7 @@ var PaliGemmaProcessor = class extends Processor {
         return expanded_sample.slice(0, bos_index) + bos_token + expanded_sample.slice(bos_index) + "\n";
       });
     } else {
-      console.warn(
+      logger.warn(
         "You are passing both `text` and `images` to `PaliGemmaProcessor`. The processor expects special image tokens in the text, as many tokens as there are images per each text. It is recommended to add `<image>` tokens in the very beginning of your text. For this call, we will infer how many images each text has and add special tokens."
       );
       input_strings = text.map(
@@ -15788,6 +16270,14 @@ var Qwen2VLProcessor = class extends Processor {
   }
 };
 
+// src/models/qwen2_5_vl/processing_qwen2_5_vl.js
+var Qwen2_5_VLProcessor = class extends Qwen2VLProcessor {
+};
+
+// src/models/qwen3_vl/processing_qwen3_vl.js
+var Qwen3VLProcessor = class extends Qwen2_5_VLProcessor {
+};
+
 // src/models/sam/processing_sam.js
 var SamProcessor = class extends Processor {
   static image_processor_class = AutoImageProcessor;
@@ -16033,6 +16523,9 @@ function getNormalizedConfig(config) {
     case "gemma3n":
     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":
@@ -16069,6 +16562,7 @@ function getNormalizedConfig(config) {
     case "nanochat":
     case "apertus":
     case "arcee":
+    case "afmoe":
     case "lfm2":
     case "lfm2_moe":
     case "smollm3":
@@ -16083,7 +16577,12 @@ function getNormalizedConfig(config) {
     case "mistral":
     case "starcoder2":
     case "qwen2":
+    case "qwen2_moe":
     case "qwen2_vl":
+    case "qwen2_5_vl_text":
+    case "qwen3_moe":
+    case "qwen3_vl_text":
+    case "qwen3_vl_moe_text":
     case "phi":
     case "phi3":
     case "phi3_v":
@@ -16228,7 +16727,10 @@ function getCacheShapes(config, options) {
     const pkv_prefix = options?.prefix ?? "past_key_values";
     const conv_prefix = pkv_prefix === "present" ? "present" : "past";
     const cache_values = {};
-    const { layer_types, num_attention_heads, num_key_value_heads, hidden_size, conv_L_cache } = config;
+    const { layer_types, num_attention_heads, num_key_value_heads, hidden_size, conv_L_cache } = (
+      /** @type {any} */
+      config
+    );
     const head_dim = hidden_size / num_attention_heads;
     const batch_size = options?.batch_size ?? 1;
     for (let i = 0; i < layer_types.length; ++i) {
@@ -16274,11 +16776,65 @@ function getCacheShapes(config, options) {
       }
       if (!layer_types || layer_types[i] === "attention") {
         for (const kv of ["key", "value"]) {
-          cache_values[`${pkv_prefix}.${i}.${kv}`] = [batch_size, num_key_value_heads, 0, head_dim];
+          cache_values[`${pkv_prefix}.${i}.${kv}`] = [batch_size, num_key_value_heads, 0, head_dim];
+        }
+      }
+    }
+    return cache_values;
+  } 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 = {};
+    const {
+      head_dim,
+      layer_types,
+      num_attention_heads,
+      num_key_value_heads,
+      hidden_size,
+      linear_num_value_heads,
+      linear_num_key_heads,
+      linear_key_head_dim,
+      linear_value_head_dim,
+      linear_conv_kernel_dim
+    } = (
+      /** @type {any} */
+      config
+    );
+    const key_dim = linear_key_head_dim * linear_num_key_heads;
+    const value_dim = linear_value_head_dim * linear_num_value_heads;
+    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) {
+      if (layer_types[i] === "full_attention") {
+        for (const kv of ["key", "value"]) {
+          cache_values[`${pkv_prefix}.${i}.${kv}`] = [batch_size, num_key_value_heads, 0, final_head_dim];
+        }
+      } else if (layer_types[i] === "linear_attention") {
+        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,
+          linear_key_head_dim,
+          linear_value_head_dim
+        ];
+      } else {
+        throw new Error(`Unsupported layer type: ${layer_types[i]}`);
       }
     }
     return cache_values;
+  } else if (["qwen3_5", "qwen3_5_moe"].includes(config.model_type)) {
+    return getCacheShapes(
+      /**@type {any} */
+      config.text_config,
+      options
+    );
   }
   return getKeyValueShapes(config, options);
 }
@@ -16383,6 +16939,22 @@ var AutoConfig = class {
 };
 
 // src/utils/model-loader.js
+function resolveExternalDataFormat(config, fullName, fileName) {
+  if (!config) return 0;
+  if (typeof config === "object" && config !== null) {
+    if (config.hasOwnProperty(fullName)) return +config[fullName];
+    if (config.hasOwnProperty(fileName)) return +config[fileName];
+    return 0;
+  }
+  return +config;
+}
+function getExternalDataChunkNames(fullName, numChunks) {
+  const names = [];
+  for (let i = 0; i < numChunks; ++i) {
+    names.push(`${fullName}_data${i === 0 ? "" : "_" + i}`);
+  }
+  return names;
+}
 async function getCoreModelFile(pretrained_model_name_or_path, fileName, options, suffix) {
   const baseName = `${fileName}${suffix}.onnx`;
   const fullPath = `${options.subfolder ?? ""}/${baseName}`;
@@ -16392,27 +16964,15 @@ async function getModelDataFiles(pretrained_model_name_or_path, fileName, suffix
   const baseName = `${fileName}${suffix}.onnx`;
   const return_path = apis.IS_NODE_ENV;
   let externalDataPromises = [];
-  if (use_external_data_format) {
-    let external_data_format;
-    if (typeof use_external_data_format === "object") {
-      if (use_external_data_format.hasOwnProperty(baseName)) {
-        external_data_format = use_external_data_format[baseName];
-      } else if (use_external_data_format.hasOwnProperty(fileName)) {
-        external_data_format = use_external_data_format[fileName];
-      } else {
-        external_data_format = false;
-      }
-    } else {
-      external_data_format = use_external_data_format;
-    }
-    const num_chunks = +external_data_format;
+  const num_chunks = resolveExternalDataFormat(use_external_data_format, baseName, fileName);
+  if (num_chunks > 0) {
     if (num_chunks > MAX_EXTERNAL_DATA_CHUNKS) {
       throw new Error(
         `The number of external data chunks (${num_chunks}) exceeds the maximum allowed value (${MAX_EXTERNAL_DATA_CHUNKS}).`
       );
     }
-    for (let i = 0; i < num_chunks; ++i) {
-      const path = `${baseName}_data${i === 0 ? "" : "_" + i}`;
+    const chunkNames = getExternalDataChunkNames(baseName, num_chunks);
+    for (const path of chunkNames) {
       const fullPath = `${options.subfolder ?? ""}/${path}`;
       externalDataPromises.push(
         new Promise(async (resolve, reject) => {
@@ -16442,18 +17002,11 @@ 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) {
   let custom_config = options.config?.["transformers.js_config"] ?? {};
-  let device = options.device ?? custom_config.device;
-  if (device && typeof device !== "string") {
-    if (device.hasOwnProperty(fileName)) {
-      device = device[fileName];
-    } else {
-      console.warn(`device not specified for "${fileName}". Using the default device.`);
-      device = null;
-    }
-  }
   const selectedDevice = (
     /** @type {import("../utils/devices.js").DeviceType} */
-    device ?? (apis.IS_NODE_ENV ? "cpu" : "wasm")
+    selectDevice(options.device ?? custom_config.device, fileName, {
+      warn: (msg) => logger.info(msg)
+    })
   );
   const executionProviders = deviceToExecutionProviders(selectedDevice);
   const device_config = custom_config.device_config ?? {};
@@ -16463,31 +17016,12 @@ async function getSession(pretrained_model_name_or_path, fileName, options, is_d
       ...device_config[selectedDevice]
     };
   }
-  let dtype = options.dtype ?? custom_config.dtype;
-  if (typeof dtype !== "string") {
-    if (dtype && dtype.hasOwnProperty(fileName)) {
-      dtype = dtype[fileName];
-    } else {
-      dtype = DEFAULT_DEVICE_DTYPE_MAPPING[selectedDevice] ?? DATA_TYPES.fp32;
-      console.warn(
-        `dtype not specified for "${fileName}". Using the default dtype (${dtype}) for this device (${selectedDevice}).`
-      );
-    }
-  }
-  if (dtype === DATA_TYPES.auto) {
-    let config_dtype = custom_config.dtype;
-    if (typeof config_dtype !== "string") {
-      config_dtype = config_dtype?.[fileName];
-    }
-    if (config_dtype && config_dtype !== DATA_TYPES.auto && DATA_TYPES.hasOwnProperty(config_dtype)) {
-      dtype = config_dtype;
-    } else {
-      dtype = DEFAULT_DEVICE_DTYPE_MAPPING[selectedDevice] ?? DATA_TYPES.fp32;
-    }
-  }
   const selectedDtype = (
     /** @type {import("../utils/dtypes.js").DataType} */
-    dtype
+    selectDtype(options.dtype ?? custom_config.dtype, fileName, selectedDevice, {
+      configDtype: custom_config.dtype,
+      warn: (msg) => logger.info(msg)
+    })
   );
   if (!DEFAULT_DTYPE_SUFFIX_MAPPING.hasOwnProperty(selectedDtype)) {
     throw new Error(`Invalid dtype: ${selectedDtype}. Should be one of: ${Object.keys(DATA_TYPES).join(", ")}`);
@@ -16507,7 +17041,7 @@ async function getSession(pretrained_model_name_or_path, fileName, options, is_d
   if (free_dimension_overrides) {
     session_options.freeDimensionOverrides ??= free_dimension_overrides;
   } else if (selectedDevice.startsWith("webnn") && !session_options.freeDimensionOverrides) {
-    console.warn(
+    logger.warn(
       `WebNN does not currently support dynamic shapes and requires 'free_dimension_overrides' to be set in config.json, preferably as a field within config["transformers.js_config"]["device_config"]["${selectedDevice}"]. When 'free_dimension_overrides' is not set, you may experience significant performance degradation.`
     );
   }
@@ -16603,8 +17137,8 @@ async function sessionRun(session, inputs) {
         return [k, unpacked];
       })
     );
-    console.error(`An error occurred during model execution: "${e}".`);
-    console.error("Inputs given to model:", formatted);
+    logger.error(`An error occurred during model execution: "${e}".`);
+    logger.error("Inputs given to model:", formatted);
     throw e;
   }
 }
@@ -16628,7 +17162,7 @@ function validateInputs(session, inputs) {
   const numInputsNeeded = session.inputNames.length;
   if (numInputsProvided > numInputsNeeded) {
     let ignored = Object.keys(inputs).filter((inputName) => !session.inputNames.includes(inputName));
-    console.warn(
+    logger.warn(
       `WARNING: Too many inputs were provided (${numInputsProvided} > ${numInputsNeeded}). The following inputs will be ignored: "${ignored.join(", ")}".`
     );
   }
@@ -17761,22 +18295,11 @@ var LogitsSampler = class extends Callable2 {
   }
   /**
    * Selects an item randomly based on the specified probabilities.
-   * @param {import("../transformers.js").DataArray} probabilities An array of probabilities to use for selection.
+   * @param {Float32Array} probabilities An array of probabilities to use for selection.
    * @returns {number} The index of the selected item.
    */
   randomSelect(probabilities) {
-    let sumProbabilities = 0;
-    for (let i = 0; i < probabilities.length; ++i) {
-      sumProbabilities += probabilities[i];
-    }
-    let r = Math.random() * sumProbabilities;
-    for (let i = 0; i < probabilities.length; ++i) {
-      r -= probabilities[i];
-      if (r <= 0) {
-        return i;
-      }
-    }
-    return 0;
+    return _weightedIndex(probabilities);
   }
   /**
    * Returns a Sampler object based on the specified options.
@@ -17868,6 +18391,14 @@ var MODEL_MAPPING_NAMES = null;
 function registerTaskMappings(mappings) {
   MODEL_MAPPING_NAMES = mappings;
 }
+function getPastLength(past_key_values) {
+  for (const name in past_key_values) {
+    if (name.startsWith("past_key_values.")) {
+      return past_key_values[name].dims.at(-2);
+    }
+  }
+  return Object.values(past_key_values)[0].dims.at(-2);
+}
 function toI64Tensor(items) {
   if (items instanceof Tensor2) {
     return items;
@@ -18282,7 +18813,7 @@ var PreTrainedModel = class extends Callable2 {
       if (modelType === void 0) {
         const type = modelName ?? config?.model_type;
         if (type !== "custom") {
-          console.warn(
+          logger.warn(
             `Model type for '${type}' not found, assuming encoder-only architecture. Please report this at ${GITHUB_ISSUE_URL}.`
           );
         }
@@ -18373,7 +18904,7 @@ var PreTrainedModel = class extends Callable2 {
       processors.push(new ClassifierFreeGuidanceLogitsProcessor(generation_config.guidance_scale));
     }
     if (generation_config.temperature === 0 && generation_config.do_sample) {
-      console.warn(
+      logger.warn(
         "`do_sample` changed to false because `temperature: 0` implies greedy sampling (always selecting the most likely token), which is incompatible with `do_sample: true`."
       );
       generation_config.do_sample = false;
@@ -18746,7 +19277,7 @@ var PreTrainedModel = class extends Callable2 {
     const pkvs = /* @__PURE__ */ Object.create(null);
     for (const name in decoderResults) {
       if (name.startsWith("present")) {
-        const newName = name.replace("present_ssm", "past_ssm").replace("present_conv", "past_conv").replace("present", "past_key_values");
+        const newName = name.replace("present_ssm", "past_ssm").replace("present_conv", "past_conv").replace("present_recurrent", "past_recurrent").replace("present", "past_key_values");
         const is_encoder_pkv = name.includes("encoder");
         if (is_encoder_pkv && pastKeyValues) {
           pkvs[newName] = pastKeyValues[newName];
@@ -18907,7 +19438,7 @@ async function generic_text_to_text_forward(self2, {
       }));
     } 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);
+      const past_length = getPastLength(past_key_values);
       attention_mask = cat(
         [
           ones([input_ids.dims[0], past_length]),
@@ -18918,7 +19449,20 @@ async function generic_text_to_text_forward(self2, {
     }
   }
   if (!position_ids) {
-    if (self2.config.model_type === "qwen2_vl") {
+    if (
+      // Handle special case for qwen vl models
+      [
+        "qwen2_vl",
+        "qwen2_5_vl",
+        "qwen2_5_vl_text",
+        "qwen3_vl",
+        "qwen3_vl_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);
     }
@@ -18985,7 +19529,7 @@ 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 ? getPastLength(model_inputs.past_key_values) : 0;
   if (!model_inputs.attention_mask) {
     let dims;
     for (const key of ["input_ids", "inputs_embeds", "position_ids"]) {
@@ -19100,6 +19644,9 @@ __export(models_exports, {
   ASTForAudioClassification: () => ASTForAudioClassification,
   ASTModel: () => ASTModel,
   ASTPreTrainedModel: () => ASTPreTrainedModel,
+  AfmoeForCausalLM: () => AfmoeForCausalLM,
+  AfmoeModel: () => AfmoeModel,
+  AfmoePreTrainedModel: () => AfmoePreTrainedModel,
   AlbertForMaskedLM: () => AlbertForMaskedLM,
   AlbertForQuestionAnswering: () => AlbertForQuestionAnswering,
   AlbertForSequenceClassification: () => AlbertForSequenceClassification,
@@ -19466,6 +20013,9 @@ __export(models_exports, {
   Olmo3Model: () => Olmo3Model,
   Olmo3PreTrainedModel: () => Olmo3PreTrainedModel,
   OlmoForCausalLM: () => OlmoForCausalLM,
+  OlmoHybridForCausalLM: () => OlmoHybridForCausalLM,
+  OlmoHybridModel: () => OlmoHybridModel,
+  OlmoHybridPreTrainedModel: () => OlmoHybridPreTrainedModel,
   OlmoModel: () => OlmoModel,
   OlmoPreTrainedModel: () => OlmoPreTrainedModel,
   OpenELMForCausalLM: () => OpenELMForCausalLM,
@@ -19504,12 +20054,26 @@ __export(models_exports, {
   PyAnnotePreTrainedModel: () => PyAnnotePreTrainedModel,
   Qwen2ForCausalLM: () => Qwen2ForCausalLM,
   Qwen2Model: () => Qwen2Model,
+  Qwen2MoeForCausalLM: () => Qwen2MoeForCausalLM,
+  Qwen2MoeModel: () => Qwen2MoeModel,
+  Qwen2MoePreTrainedModel: () => Qwen2MoePreTrainedModel,
   Qwen2PreTrainedModel: () => Qwen2PreTrainedModel,
   Qwen2VLForConditionalGeneration: () => Qwen2VLForConditionalGeneration,
   Qwen2VLPreTrainedModel: () => Qwen2VLPreTrainedModel,
+  Qwen2_5_VLForConditionalGeneration: () => Qwen2_5_VLForConditionalGeneration,
   Qwen3ForCausalLM: () => Qwen3ForCausalLM,
   Qwen3Model: () => Qwen3Model,
+  Qwen3MoeForCausalLM: () => Qwen3MoeForCausalLM,
+  Qwen3MoeModel: () => Qwen3MoeModel,
+  Qwen3MoePreTrainedModel: () => Qwen3MoePreTrainedModel,
+  Qwen3NextForCausalLM: () => Qwen3NextForCausalLM,
+  Qwen3NextModel: () => Qwen3NextModel,
+  Qwen3NextPreTrainedModel: () => Qwen3NextPreTrainedModel,
   Qwen3PreTrainedModel: () => Qwen3PreTrainedModel,
+  Qwen3VLForConditionalGeneration: () => Qwen3VLForConditionalGeneration,
+  Qwen3VLMoeForConditionalGeneration: () => Qwen3VLMoeForConditionalGeneration,
+  Qwen3_5ForConditionalGeneration: () => Qwen3_5ForConditionalGeneration,
+  Qwen3_5MoeForConditionalGeneration: () => Qwen3_5MoeForConditionalGeneration,
   RFDetrForObjectDetection: () => RFDetrForObjectDetection,
   RFDetrModel: () => RFDetrModel,
   RFDetrObjectDetectionOutput: () => RFDetrObjectDetectionOutput,
@@ -19720,6 +20284,14 @@ var ApertusModel = class extends ApertusPreTrainedModel {
 var ApertusForCausalLM = class extends ApertusPreTrainedModel {
 };
 
+// src/models/afmoe/modeling_afmoe.js
+var AfmoePreTrainedModel = class extends PreTrainedModel {
+};
+var AfmoeModel = class extends AfmoePreTrainedModel {
+};
+var AfmoeForCausalLM = class extends AfmoePreTrainedModel {
+};
+
 // src/models/arcee/modeling_arcee.js
 var ArceePreTrainedModel = class extends PreTrainedModel {
 };
@@ -22061,6 +22633,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 {
 };
@@ -22265,6 +22845,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 = [
@@ -22279,6 +22867,7 @@ var Qwen2VLPreTrainedModel = class extends PreTrainedModel {
   ];
 };
 var Qwen2VLForConditionalGeneration = class extends Qwen2VLPreTrainedModel {
+  image_grid_thw_name = "grid_thw";
   /**
    * Calculate the 3D rope index based on image and video's temporal, height and width in LLM.
    *
@@ -22443,7 +23032,10 @@ var Qwen2VLForConditionalGeneration = class extends Qwen2VLPreTrainedModel {
     }
   }
   async encode_image({ pixel_values, image_grid_thw }) {
-    const features = (await sessionRun(this.sessions["vision_encoder"], { pixel_values, grid_thw: image_grid_thw })).image_features;
+    const features = (await sessionRun(this.sessions["vision_encoder"], {
+      pixel_values,
+      [this.image_grid_thw_name]: image_grid_thw
+    })).image_features;
     return features;
   }
   _merge_input_ids_with_image_features(kwargs) {
@@ -22464,15 +23056,41 @@ 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 = getPastLength(model_inputs.past_key_values);
+        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;
   }
 };
 
+// src/models/qwen2_5_vl/modeling_qwen2_5_vl.js
+var Qwen2_5_VLForConditionalGeneration = class extends Qwen2VLForConditionalGeneration {
+  image_grid_thw_name = "image_grid_thw";
+};
+
 // src/models/qwen3/modeling_qwen3.js
 var Qwen3PreTrainedModel = class extends PreTrainedModel {
 };
@@ -22481,6 +23099,38 @@ 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 {
+};
+
+// src/models/qwen3_vl_moe/modeling_qwen3_vl_moe.js
+var Qwen3VLMoeForConditionalGeneration = class extends Qwen3VLForConditionalGeneration {
+};
+
+// src/models/qwen3_5/modeling_qwen3_5.js
+var Qwen3_5ForConditionalGeneration = class extends Qwen3VLForConditionalGeneration {
+};
+
+// src/models/qwen3_5_moe/modeling_qwen3_5_moe.js
+var Qwen3_5MoeForConditionalGeneration = class extends Qwen3_5ForConditionalGeneration {
+};
+
 // src/models/resnet/modeling_resnet.js
 var ResNetPreTrainedModel = class extends PreTrainedModel {
 };
@@ -23538,7 +24188,7 @@ var WhisperForConditionalGeneration = class extends WhisperPreTrainedModel {
     const task = generation_config.task;
     if (generation_config.is_multilingual) {
       if (!language) {
-        console.warn("No language specified - defaulting to English (en).");
+        logger.warn("No language specified - defaulting to English (en).");
         language = "en";
       }
       const language_code = whisper_language_to_code(language);
@@ -23553,7 +24203,7 @@ var WhisperForConditionalGeneration = class extends WhisperPreTrainedModel {
     if (!generation_config.return_timestamps && generation_config.no_timestamps_token_id && init_tokens.at(-1) !== generation_config.no_timestamps_token_id) {
       init_tokens.push(generation_config.no_timestamps_token_id);
     } else if (generation_config.return_timestamps && init_tokens.at(-1) === generation_config.no_timestamps_token_id) {
-      console.warn(
+      logger.warn(
         "<|notimestamps|> prompt token is removed from generation_config since `return_timestamps` is set to `true`."
       );
       init_tokens.pop();
@@ -23595,7 +24245,7 @@ var WhisperForConditionalGeneration = class extends WhisperPreTrainedModel {
         );
       }
       if (generation_config.task === "translate") {
-        console.warn("Token-level timestamps may not be reliable for task 'translate'.");
+        logger.warn("Token-level timestamps may not be reliable for task 'translate'.");
       }
       generation_config.output_attentions = true;
       generation_config.return_dict_in_generate = true;
@@ -23636,13 +24286,13 @@ var WhisperForConditionalGeneration = class extends WhisperPreTrainedModel {
       );
     }
     if (num_frames == null) {
-      console.warn(
+      logger.warn(
         "`num_frames` has not been set, meaning the entire audio will be analyzed. This may lead to inaccurate token-level timestamps for short audios (< 30 seconds)."
       );
     }
     let median_filter_width = this.config.median_filter_width;
     if (median_filter_width === void 0) {
-      console.warn("Model config has no `median_filter_width`, using default value of 7.");
+      logger.warn("Model config has no `median_filter_width`, using default value of 7.");
       median_filter_width = 7;
     }
     const batch = generate_outputs.cross_attentions;
@@ -23960,6 +24610,7 @@ var MODEL_MAPPING_NAMES_DECODER_ONLY = /* @__PURE__ */ new Map([
   ["apertus", "ApertusModel"],
   ["nanochat", "NanoChatModel"],
   ["arcee", "ArceeModel"],
+  ["afmoe", "AfmoeModel"],
   ["lfm2", "Lfm2Model"],
   ["lfm2_moe", "Lfm2MoeModel"],
   ["smollm3", "SmolLM3Model"],
@@ -23967,6 +24618,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"],
@@ -23980,7 +24632,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"],
@@ -23988,7 +24643,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"],
@@ -24074,6 +24729,7 @@ var MODEL_FOR_CAUSAL_LM_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["apertus", "ApertusForCausalLM"],
   ["llama4_text", "Llama4ForCausalLM"],
   ["arcee", "ArceeForCausalLM"],
+  ["afmoe", "AfmoeForCausalLM"],
   ["lfm2", "Lfm2ForCausalLM"],
   ["lfm2_moe", "Lfm2MoeForCausalLM"],
   ["smollm3", "SmolLM3ForCausalLM"],
@@ -24081,6 +24737,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"],
@@ -24094,7 +24751,10 @@ var MODEL_FOR_CAUSAL_LM_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["glm", "GlmForCausalLM"],
   ["openelm", "OpenELMForCausalLM"],
   ["qwen2", "Qwen2ForCausalLM"],
+  ["qwen2_moe", "Qwen2MoeForCausalLM"],
   ["qwen3", "Qwen3ForCausalLM"],
+  ["qwen3_moe", "Qwen3MoeForCausalLM"],
+  ["qwen3_next", "Qwen3NextForCausalLM"],
   ["phi", "PhiForCausalLM"],
   ["phi3", "Phi3ForCausalLM"],
   ["mpt", "MptForCausalLM"],
@@ -24103,7 +24763,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"],
@@ -24164,7 +24824,12 @@ var MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["llava_onevision", "LlavaOnevisionForConditionalGeneration"],
   ["moondream1", "Moondream1ForConditionalGeneration"],
   ["florence2", "Florence2ForConditionalGeneration"],
-  ["qwen2-vl", "Qwen2VLForConditionalGeneration"],
+  ["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"],
   ["idefics3", "Idefics3ForConditionalGeneration"],
   ["smolvlm", "SmolVLMForConditionalGeneration"],
   ["paligemma", "PaliGemmaForConditionalGeneration"],
@@ -24364,17 +25029,18 @@ for (const [name, model, type] of CUSTOM_MAPPING) {
   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 = {
@@ -24423,6 +25089,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,
@@ -24454,7 +25132,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) {
@@ -24470,7 +25148,7 @@ var PretrainedMixin = class {
     }
     if (this.BASE_IF_FAIL) {
       if (!CUSTOM_ARCHITECTURES.has(model_type)) {
-        console.warn(`Unknown model class "${model_type}", attempting to construct from base class.`);
+        logger.warn(`Unknown model class "${model_type}", attempting to construct from base class.`);
       }
       return await PreTrainedModel.from_pretrained(pretrained_model_name_or_path, options);
     } else {
@@ -24873,6 +25551,10 @@ function isChat(x) {
 }
 var TextGenerationPipeline = class extends /** @type {new (options: TextPipelineConstructorArgs) => TextGenerationPipelineType} */
 Pipeline {
+  /**
+   * @param {string | string[] | import('../tokenization_utils.js').Message[] | import('../tokenization_utils.js').Message[][]} texts
+   * @param {Partial<TextGenerationConfig>} generate_kwargs
+   */
   async _call(texts, generate_kwargs = {}) {
     let isBatched = false;
     let isChatInput = false;
@@ -24968,12 +25650,12 @@ Pipeline {
     );
     this.entailment_id = this.label2id["entailment"];
     if (this.entailment_id === void 0) {
-      console.warn("Could not find 'entailment' in label2id mapping. Using 2 as entailment_id.");
+      logger.warn("Could not find 'entailment' in label2id mapping. Using 2 as entailment_id.");
       this.entailment_id = 2;
     }
     this.contradiction_id = this.label2id["contradiction"] ?? this.label2id["not_entailment"];
     if (this.contradiction_id === void 0) {
-      console.warn("Could not find 'contradiction' in label2id mapping. Using 0 as contradiction_id.");
+      logger.warn("Could not find 'contradiction' in label2id mapping. Using 0 as contradiction_id.");
       this.contradiction_id = 0;
     }
   }
@@ -25111,10 +25793,10 @@ Pipeline {
   }
   async _call_wav2vec2(audio, kwargs) {
     if (kwargs.language) {
-      console.warn('`language` parameter is not yet supported for `wav2vec2` models, defaulting to "English".');
+      logger.warn('`language` parameter is not yet supported for `wav2vec2` models, defaulting to "English".');
     }
     if (kwargs.task) {
-      console.warn('`task` parameter is not yet supported for `wav2vec2` models, defaulting to "transcribe".');
+      logger.warn('`task` parameter is not yet supported for `wav2vec2` models, defaulting to "transcribe".');
     }
     const single = !Array.isArray(audio);
     const batchedAudio = single ? [audio] : audio;
@@ -25246,7 +25928,7 @@ Pipeline {
   }
   async _prepare_speaker_embeddings(speaker_embeddings, batch_size) {
     if (typeof speaker_embeddings === "string" || speaker_embeddings instanceof URL) {
-      speaker_embeddings = new Float32Array(await (await fetch(speaker_embeddings)).arrayBuffer());
+      speaker_embeddings = new Float32Array(await (await env.fetch(speaker_embeddings)).arrayBuffer());
     }
     if (speaker_embeddings instanceof Float32Array) {
       speaker_embeddings = new Tensor2("float32", speaker_embeddings, [speaker_embeddings.length]);
@@ -25332,7 +26014,7 @@ Pipeline {
   }
   async _call_text_to_spectrogram(text_inputs, { speaker_embeddings }) {
     if (!this.vocoder) {
-      console.log("No vocoder specified, using default HifiGan vocoder.");
+      logger.info("No vocoder specified, using default HifiGan vocoder.");
       this.vocoder = await AutoModel.from_pretrained(this.DEFAULT_VOCODER_ID, { dtype: "fp32" });
     }
     const { input_ids } = this.tokenizer(text_inputs, {
@@ -25799,43 +26481,33 @@ Pipeline {
   }
 };
 
-// src/pipelines.js
+// 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: {
@@ -25845,40 +26517,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: {
@@ -25888,12 +26550,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"
@@ -25901,47 +26560,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"
@@ -25949,124 +26591,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: {
@@ -26076,7 +26680,6 @@ var SUPPORTED_TASKS = Object.freeze({
     type: "text"
   },
   "image-feature-extraction": {
-    processor: AutoProcessor,
     pipeline: ImageFeatureExtractionPipeline,
     model: [AutoModelForImageFeatureExtraction, AutoModel],
     default: {
@@ -26095,7 +26698,193 @@ var TASK_ALIASES = Object.freeze({
   // Add for backwards compatibility
   embeddings: "feature-extraction"
 });
-async function pipeline3(task, model = null, {
+
+// src/utils/model_registry/get_model_files.js
+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 });
+  const files = [
+    // Add config.json (always loaded)
+    "config.json"
+  ];
+  const custom_config = config["transformers.js_config"] ?? {};
+  const use_external_data_format = custom_config.use_external_data_format;
+  const subfolder = "onnx";
+  const rawDevice = overrideDevice ?? custom_config.device;
+  let dtype = overrideDtype ?? custom_config.dtype;
+  let modelType;
+  const architectures = (
+    /** @type {string[]} */
+    config.architectures || []
+  );
+  let foundInMapping = false;
+  for (const arch of architectures) {
+    const mappedType = MODEL_TYPE_MAPPING.get(arch);
+    if (mappedType !== void 0) {
+      modelType = mappedType;
+      foundInMapping = true;
+      break;
+    }
+  }
+  if (!foundInMapping && config.model_type) {
+    const mappedType = MODEL_TYPE_MAPPING.get(config.model_type);
+    if (mappedType !== void 0) {
+      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)";
+    logger.warn(
+      `[get_model_files] Architecture(s) not found in MODEL_TYPE_MAPPING: [${archList}] for model type '${config.model_type}'. Falling back to EncoderOnly (single model.onnx file). If you encounter issues, please report at: ${GITHUB_ISSUE_URL}`
+    );
+    modelType = MODEL_TYPES.EncoderOnly;
+  }
+  const add_model_file = (fileName, baseName = null) => {
+    baseName = baseName ?? fileName;
+    const selectedDevice = selectDevice(rawDevice, fileName);
+    const selectedDtype = selectDtype(dtype, fileName, selectedDevice);
+    const suffix = DEFAULT_DTYPE_SUFFIX_MAPPING[selectedDtype] ?? "";
+    const fullName = `${baseName}${suffix}.onnx`;
+    const fullPath = subfolder ? `${subfolder}/${fullName}` : fullName;
+    files.push(fullPath);
+    const num_chunks = resolveExternalDataFormat(use_external_data_format, fullName, fileName);
+    for (const dataFileName of getExternalDataChunkNames(fullName, num_chunks)) {
+      const dataFilePath = subfolder ? `${subfolder}/${dataFileName}` : dataFileName;
+      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);
+  }
+  return files;
+}
+
+// src/utils/model_registry/get_processor_files.js
+async function get_processor_files(modelId) {
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  const metadata = await get_file_metadata(modelId, IMAGE_PROCESSOR_NAME, {});
+  return metadata.exists ? [IMAGE_PROCESSOR_NAME] : [];
+}
+
+// src/utils/model_registry/get_files.js
+async function get_files(modelId, {
+  config = null,
+  dtype = null,
+  device = null,
+  model_file_name = null,
+  include_tokenizer = true,
+  include_processor = true
+} = {}) {
+  const files = await get_model_files(modelId, { config, dtype, device, model_file_name });
+  if (include_tokenizer) {
+    const tokenizerFiles = await get_tokenizer_files(modelId);
+    files.push(...tokenizerFiles);
+  }
+  if (include_processor) {
+    const processorFiles = await get_processor_files(modelId);
+    files.push(...processorFiles);
+  }
+  return files;
+}
+
+// src/utils/model_registry/get_pipeline_files.js
+async function get_pipeline_files(task, modelId, options = {}) {
+  task = TASK_ALIASES[task] ?? task;
+  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,
+    include_processor
+  });
+}
+
+// src/pipelines.js
+async function pipeline2(task, model = null, {
   progress_callback = null,
   config = null,
   cache_dir = null,
@@ -26115,13 +26904,51 @@ async function pipeline3(task, model = null, {
   }
   if (!model) {
     model = pipelineInfo.default.model;
-    console.log(`No model specified. Using default model: "${model}".`);
+    logger.info(`No model specified. Using default model: "${model}".`);
     if (!dtype && pipelineInfo.default.dtype) {
       dtype = pipelineInfo.default.dtype;
     }
   }
+  const expected_files = await get_pipeline_files(task, model, {
+    device,
+    dtype
+  });
+  let files_loading = {};
+  if (progress_callback) {
+    const metadata = await Promise.all(expected_files.map(async (file) => get_file_metadata(model, file)));
+    metadata.forEach((m, i) => {
+      if (m.exists) {
+        files_loading[expected_files[i]] = {
+          loaded: 0,
+          total: m.size ?? 0
+        };
+      }
+    });
+  }
   const pretrainedOptions = {
-    progress_callback,
+    progress_callback: progress_callback ? (
+      /** @param {import('./utils/core.js').ProgressInfo} info */
+      (info) => {
+        if (info.status === "progress") {
+          files_loading[info.file] = {
+            loaded: info.loaded,
+            total: info.total
+          };
+          const loaded = Object.values(files_loading).reduce((acc, curr) => acc + curr.loaded, 0);
+          const total = Object.values(files_loading).reduce((acc, curr) => acc + curr.total, 0);
+          const progress = total > 0 ? loaded / total * 100 : 0;
+          progress_callback({
+            status: "progress_total",
+            name: info.name,
+            progress,
+            loaded,
+            total,
+            files: structuredClone(files_loading)
+          });
+        }
+        progress_callback(info);
+      }
+    ) : void 0,
     config,
     cache_dir,
     local_files_only,
@@ -26133,13 +26960,31 @@ async function pipeline3(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,
@@ -26148,48 +26993,6 @@ async function pipeline3(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;
@@ -26438,7 +27241,7 @@ async function load_video(src, { num_frames = null, fps = null } = {}) {
   }
   await new Promise((resolve) => video.onloadedmetadata = resolve);
   if (video.seekable.start(0) === video.seekable.end(0)) {
-    const response = await fetch(video.src);
+    const response = await env.fetch(video.src);
     const blob = await response.blob();
     video.src = URL.createObjectURL(blob);
     await new Promise((resolve) => video.onloadedmetadata = resolve);
@@ -26474,11 +27277,362 @@ async function load_video(src, { num_frames = null, fps = null } = {}) {
   video.remove();
   return new RawVideo(frames, duration);
 }
+
+// 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 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);
+      return { file: filename, cached: !!cached };
+    })
+  );
+  return { allCached: fileStatuses.every((f) => f.cached), files: fileStatuses };
+}
+async function is_file_cached(modelId, filename, options = {}) {
+  const cache = await getCache(options?.cache_dir);
+  if (!cache) return false;
+  const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache);
+  return !!await checkCachedResource(cache, 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");
+  }
+  const files = await get_files(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");
+  }
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  const files = await get_pipeline_files(task, modelId, options);
+  return await check_files_cache(modelId, files, 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) {
+    return {
+      filesDeleted: 0,
+      filesCached: 0,
+      files: files.map((filename) => ({ file: filename, deleted: false, wasCached: false }))
+    };
+  }
+  if (!cache.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 wasCached = !!cached;
+      let deleted = false;
+      if (wasCached) {
+        const deletedWithProposed = await cache.delete(proposedCacheKey);
+        const deletedWithLocal = !deletedWithProposed && proposedCacheKey !== localPath ? await cache.delete(localPath) : false;
+        deleted = deletedWithProposed || deletedWithLocal;
+      }
+      return { file: filename, deleted, wasCached };
+    })
+  );
+  return {
+    filesDeleted: results.filter((r) => r.deleted).length,
+    filesCached: results.filter((r) => r.wasCached).length,
+    files: results
+  };
+}
+async function clear_cache(modelId, options = {}) {
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  const files = await get_files(modelId, options);
+  return await clear_files_from_cache(modelId, files, options);
+}
+async function clear_pipeline_cache(task, modelId, options = {}) {
+  if (!task) {
+    throw new Error("task is required");
+  }
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  const files = await get_pipeline_files(task, modelId, options);
+  return await clear_files_from_cache(modelId, files, options);
+}
+
+// src/utils/model_registry/ModelRegistry.js
+var ModelRegistry = class {
+  /**
+   * Get all files (model, tokenizer, processor) needed for a model.
+   *
+   * @param {string} modelId - The model id (e.g., "onnx-community/bert-base-uncased-ONNX")
+   * @param {Object} [options] - Optional parameters
+   * @param {import('../../configs.js').PretrainedConfig} [options.config=null] - 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
+   * @param {string} [options.model_file_name=null] - Override the model file name (excluding .onnx suffix)
+   * @param {boolean} [options.include_tokenizer=true] - Whether to check for tokenizer files
+   * @param {boolean} [options.include_processor=true] - Whether to check for processor files
+   * @returns {Promise<string[]>} Array of file paths
+   *
+   * @example
+   * const files = await ModelRegistry.get_files('onnx-community/gpt2-ONNX');
+   * console.log(files); // ['config.json', 'tokenizer.json', 'onnx/model_q4.onnx', ...]
+   */
+  static async get_files(modelId, options = {}) {
+    return get_files(modelId, options);
+  }
+  /**
+   * Get all files needed for a specific pipeline task.
+   * 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 (e.g., "onnx-community/bert-base-uncased-ONNX")
+   * @param {Object} [options] - Optional parameters
+   * @param {import('../../configs.js').PretrainedConfig} [options.config=null] - 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
+   * @param {string} [options.model_file_name=null] - Override the model file name (excluding .onnx suffix)
+   * @returns {Promise<string[]>} Array of file paths
+   *
+   * @example
+   * const files = await ModelRegistry.get_pipeline_files('text-generation', 'onnx-community/gpt2-ONNX');
+   * console.log(files); // ['config.json', 'tokenizer.json', 'onnx/model_q4.onnx', ...]
+   */
+  static async get_pipeline_files(task, modelId, options = {}) {
+    return get_pipeline_files(task, modelId, options);
+  }
+  /**
+   * Get model files needed for a specific model.
+   *
+   * @param {string} modelId - The model id
+   * @param {Object} [options] - Optional parameters
+   * @param {import('../../configs.js').PretrainedConfig} [options.config=null] - 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
+   * @param {string} [options.model_file_name=null] - Override the model file name (excluding .onnx suffix)
+   * @returns {Promise<string[]>} Array of model file paths
+   *
+   * @example
+   * const files = await ModelRegistry.get_model_files('onnx-community/bert-base-uncased-ONNX');
+   * console.log(files); // ['config.json', 'onnx/model_q4.onnx', 'generation_config.json']
+   */
+  static async get_model_files(modelId, options = {}) {
+    return get_model_files(modelId, options);
+  }
+  /**
+   * Get tokenizer files needed for a specific model.
+   *
+   * @param {string} modelId - The model id
+   * @returns {Promise<string[]>} Array of tokenizer file paths
+   *
+   * @example
+   * const files = await ModelRegistry.get_tokenizer_files('onnx-community/gpt2-ONNX');
+   * console.log(files); // ['tokenizer.json', 'tokenizer_config.json']
+   */
+  static async get_tokenizer_files(modelId) {
+    return get_tokenizer_files(modelId);
+  }
+  /**
+   * Get processor files needed for a specific model.
+   *
+   * @param {string} modelId - The model id
+   * @returns {Promise<string[]>} Array of processor file paths
+   *
+   * @example
+   * const files = await ModelRegistry.get_processor_files('onnx-community/vit-base-patch16-224-ONNX');
+   * console.log(files); // ['preprocessor_config.json']
+   */
+  static async get_processor_files(modelId) {
+    return get_processor_files(modelId);
+  }
+  /**
+   * 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<boolean>} Whether all required files are cached
+   *
+   * @example
+   * 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);
+  }
+  /**
+   * 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} 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_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.
+   *
+   * @param {string} path_or_repo_id - Model id or path
+   * @param {string} filename - The file name
+   * @param {import('../hub.js').PretrainedOptions} [options] - Optional parameters
+   * @returns {Promise<{exists: boolean, size?: number, contentType?: string, fromCache?: boolean}>} File metadata
+   *
+   * @example
+   * const metadata = await ModelRegistry.get_file_metadata('onnx-community/gpt2-ONNX', 'config.json');
+   * console.log(metadata.exists, metadata.size); // true, 665
+   */
+  static async get_file_metadata(path_or_repo_id, filename, options = {}) {
+    return get_file_metadata(path_or_repo_id, filename, options);
+  }
+  /**
+   * Clears all cached files for a given model.
+   * Automatically determines which files are needed and removes them from the cache.
+   *
+   * @param {string} modelId - The model id (e.g., "onnx-community/gpt2-ONNX")
+   * @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] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device] - Override device
+   * @param {boolean} [options.include_tokenizer=true] - Whether to clear tokenizer files
+   * @param {boolean} [options.include_processor=true] - Whether to clear processor files
+   * @returns {Promise<import('./clear_cache.js').CacheClearResult>} Object with deletion statistics and file status
+   *
+   * @example
+   * const result = await ModelRegistry.clear_cache('onnx-community/bert-base-uncased-ONNX');
+   * console.log(`Deleted ${result.filesDeleted} of ${result.filesCached} cached files`);
+   */
+  static async clear_cache(modelId, options = {}) {
+    return clear_cache(modelId, options);
+  }
+  /**
+   * Clears all cached files for a specific pipeline task.
+   * Automatically determines which components are needed based on the task.
+   *
+   * @param {string} task - The pipeline task (e.g., "text-generation", "image-classification")
+   * @param {string} modelId - The model id (e.g., "onnx-community/gpt2-ONNX")
+   * @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] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device] - Override device
+   * @returns {Promise<import('./clear_cache.js').CacheClearResult>} Object with deletion statistics and file status
+   *
+   * @example
+   * const result = await ModelRegistry.clear_pipeline_cache('text-generation', 'onnx-community/gpt2-ONNX');
+   * console.log(`Deleted ${result.filesDeleted} of ${result.filesCached} cached files`);
+   */
+  static async clear_pipeline_cache(task, modelId, options = {}) {
+    return clear_pipeline_cache(task, modelId, options);
+  }
+};
 export {
   ASTFeatureExtractor,
   ASTForAudioClassification,
   ASTModel,
   ASTPreTrainedModel,
+  AfmoeForCausalLM,
+  AfmoeModel,
+  AfmoePreTrainedModel,
   AlbertForMaskedLM,
   AlbertForQuestionAnswering,
   AlbertForSequenceClassification,
@@ -26845,6 +27999,7 @@ export {
   LlavaPreTrainedModel,
   LlavaProcessor,
   LlavaQwen2ForCausalLM,
+  LogLevel,
   LogitsProcessor,
   LogitsProcessorList,
   LogitsWarper,
@@ -26944,6 +28099,7 @@ export {
   MobileViTV2ForImageClassification,
   MobileViTV2Model,
   MobileViTV2PreTrainedModel,
+  ModelRegistry,
   ModernBertDecoderForCausalLM,
   ModernBertDecoderModel,
   ModernBertDecoderPreTrainedModel,
@@ -26994,6 +28150,9 @@ export {
   Olmo3Model,
   Olmo3PreTrainedModel,
   OlmoForCausalLM,
+  OlmoHybridForCausalLM,
+  OlmoHybridModel,
+  OlmoHybridPreTrainedModel,
   OlmoModel,
   OlmoPreTrainedModel,
   OpenELMForCausalLM,
@@ -27049,15 +28208,31 @@ export {
   QuestionAnsweringPipeline,
   Qwen2ForCausalLM,
   Qwen2Model,
+  Qwen2MoeForCausalLM,
+  Qwen2MoeModel,
+  Qwen2MoePreTrainedModel,
   Qwen2PreTrainedModel,
   Qwen2Tokenizer,
   Qwen2VLForConditionalGeneration,
   Qwen2VLImageProcessor,
   Qwen2VLPreTrainedModel,
   Qwen2VLProcessor,
+  Qwen2_5_VLForConditionalGeneration,
+  Qwen2_5_VLProcessor,
   Qwen3ForCausalLM,
   Qwen3Model,
+  Qwen3MoeForCausalLM,
+  Qwen3MoeModel,
+  Qwen3MoePreTrainedModel,
+  Qwen3NextForCausalLM,
+  Qwen3NextModel,
+  Qwen3NextPreTrainedModel,
   Qwen3PreTrainedModel,
+  Qwen3VLForConditionalGeneration,
+  Qwen3VLMoeForConditionalGeneration,
+  Qwen3VLProcessor,
+  Qwen3_5ForConditionalGeneration,
+  Qwen3_5MoeForConditionalGeneration,
   RFDetrForObjectDetection,
   RFDetrModel,
   RFDetrObjectDetectionOutput,
@@ -27310,10 +28485,11 @@ export {
   ones,
   ones_like,
   permute,
-  pipeline3 as pipeline,
+  pipeline2 as pipeline,
   quantize_embeddings,
   rand,
   randn,
+  random,
   read_audio,
   rfft,
   slice2 as slice,